activeagent 0.6.3 → 1.0.0.rc1

data/lib/active_agent/generation_provider/parameter_builder.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module GenerationProvider
-    module ParameterBuilder
-      extend ActiveSupport::Concern
-
-      def prompt_parameters(overrides = {})
-        base_params = build_base_parameters
-        provider_params = build_provider_parameters
-
-        # Merge parameters with proper precedence:
-        # 1. Overrides (highest priority)
-        # 2. Prompt options
-        # 3. Provider-specific parameters
-        # 4. Base parameters (lowest priority)
-        base_params
-          .merge(provider_params)
-          .merge(extract_prompt_options)
-          .merge(overrides)
-          .compact
-      end
-
-      protected
-
-      def build_base_parameters
-        {
-          model: determine_model,
-          messages: provider_messages(@prompt.messages),
-          temperature: determine_temperature
-        }.tap do |params|
-          # Add optional parameters if present
-          params[:max_tokens] = determine_max_tokens if determine_max_tokens
-          params[:tools] = format_tools(@prompt.actions) if @prompt.actions.present?
-        end
-      end
-
-      def build_provider_parameters
-        # Override in provider for specific parameters
-        # For example, Anthropic needs 'system' parameter instead of system message
-        {}
-      end
-
-      def extract_prompt_options
-        # Extract relevant options from prompt
-        options = {}
-
-        # Common options that map directly
-        [ :stream, :top_p, :frequency_penalty, :presence_penalty, :seed, :stop, :user, :plugins ].each do |key|
-          options[key] = @prompt.options[key] if @prompt.options.key?(key)
-        end
-
-        # Handle response format for structured output
-        if @prompt.output_schema.present?
-          options[:response_format] = build_response_format
-        end
-
-        options
-      end
-
-      def determine_model
-        @prompt.options[:model] || @model_name || @config["model"]
-      end
-
-      def determine_temperature
-        @prompt.options[:temperature] || @config["temperature"] || 0.7
-      end
-
-      def determine_max_tokens
-        @prompt.options[:max_tokens] || @config["max_tokens"]
-      end
-
-      def build_response_format
-        # Default OpenAI-style response format
-        # Override in provider for different formats
-        {
-          type: "json_schema",
-          json_schema: @prompt.output_schema
-        }
-      end
-
-      # Embedding-specific parameters
-      def embeddings_parameters(input: nil, model: nil, **options)
-        {
-          model: model || determine_embedding_model,
-          input: input || format_embedding_input,
-          dimensions: options[:dimensions] || @config["embedding_dimensions"],
-          encoding_format: options[:encoding_format] || "float"
-        }.compact
-      end
-
-      def determine_embedding_model
-        @prompt.options[:embedding_model] || @config["embedding_model"] || "text-embedding-3-small"
-      end
-
-      def format_embedding_input
-        # Handle single or batch embedding inputs
-        if @prompt.message
-          @prompt.message.content
-        elsif @prompt.messages
-          @prompt.messages.map(&:content)
-        else
-          nil
-        end
-      end
-
-      module ClassMethods
-        # Class-level configuration for default parameters
-        def default_parameters(params = {})
-          @default_parameters = params
-        end
-
-        def get_default_parameters
-          @default_parameters || {}
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider/response.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module GenerationProvider
-    class Response
-      attr_reader :message, :prompt, :raw_response, :raw_request
-      attr_accessor :metadata
-
-      def initialize(prompt:, message: nil, raw_response: nil, raw_request: nil, metadata: nil)
-        @prompt = prompt
-        @message = message || prompt.message
-        @raw_response = raw_response
-        @raw_request = sanitize_request(raw_request)
-        @metadata = metadata || {}
-      end
-
-      # Extract usage statistics from the raw response
-      def usage
-        return nil unless @raw_response
-
-        # Most providers store usage in the same format
-        if @raw_response.is_a?(Hash) && @raw_response["usage"]
-          @raw_response["usage"]
-        end
-      end
-
-      # Helper methods for common usage stats
-      def prompt_tokens
-        usage&.dig("prompt_tokens")
-      end
-
-      def completion_tokens
-        usage&.dig("completion_tokens")
-      end
-
-      def total_tokens
-        usage&.dig("total_tokens")
-      end
-
-      private
-
-      def sanitize_request(request)
-        return nil if request.nil?
-        return request unless request.is_a?(Hash)
-
-        # Deep clone the request to avoid modifying the original
-        sanitized = request.deep_dup
-
-        # Sanitize any string values in the request
-        sanitize_hash_values(sanitized)
-      end
-
-      def sanitize_hash_values(hash)
-        hash.each do |key, value|
-          case value
-          when String
-            # Use ActiveAgent's sanitize_credentials to replace sensitive data
-            hash[key] = ActiveAgent.sanitize_credentials(value)
-          when Hash
-            sanitize_hash_values(value)
-          when Array
-            value.each_with_index do |item, index|
-              if item.is_a?(String)
-                value[index] = ActiveAgent.sanitize_credentials(item)
-              elsif item.is_a?(Hash)
-                sanitize_hash_values(item)
-              end
-            end
-          end
-        end
-        hash
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider/responses_adapter.rb

@@ -1,44 +0,0 @@
-require_relative "base_adapter"
-
-module ActiveAgent
-  module GenerationProvider
-    class ResponsesAdapter < BaseAdapter
-      def initialize(prompt)
-        super(prompt)
-        @prompt = prompt
-      end
-
-      def input
-          messages.map do |message|
-          if message.content.is_a?(Array)
-            {
-              role: message.role,
-              content: message.content.map do |content_part|
-                if content_part.is_a?(String)
-                  { type: "input_text", text: content_part }
-                elsif content_part.is_a?(ActiveAgent::ActionPrompt::Message) && content_part.content_type == "input_text"
-                  { type: "input_text", text: content_part.content }
-                elsif content_part.is_a?(ActiveAgent::ActionPrompt::Message) && content_part.content_type == "image_data"
-                  { type: "input_image", image_url: content_part.content }
-                elsif content_part.is_a?(ActiveAgent::ActionPrompt::Message) && content_part.content_type == "file_data"
-                  { type: "input_file", filename: content_part.metadata[:filename], file_data: content_part.content }
-                else
-                  raise ArgumentError, "Unsupported content type in message"
-                end
-              end.compact
-            }
-          else
-            {
-              role: message.role,
-              content: message.content
-            }
-          end
-        end.compact
-      end
-
-      def messages
-        prompt.messages
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider/stream_processing.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module GenerationProvider
-    module StreamProcessing
-      extend ActiveSupport::Concern
-
-      included do
-        attr_accessor :stream_buffer, :stream_context
-      end
-
-      def provider_stream
-        agent_stream = prompt.options[:stream]
-        message = initialize_stream_message
-
-        @response = ActiveAgent::GenerationProvider::Response.new(prompt:, message:)
-
-        proc do |chunk|
-          process_stream_chunk(chunk, message, agent_stream)
-        end
-      end
-
-      protected
-
-      def initialize_stream_message
-        ActiveAgent::ActionPrompt::Message.new(content: "", role: :assistant)
-      end
-
-      def process_stream_chunk(chunk, message, agent_stream)
-        # Default implementation - must be overridden in provider
-        raise NotImplementedError, "Providers must implement process_stream_chunk"
-      end
-
-      def handle_stream_delta(delta, message, agent_stream)
-        # Common delta handling logic
-        new_content = extract_content_from_delta(delta)
-        if new_content && !new_content.blank?
-          message.content += new_content
-          agent_stream&.call(message, new_content, false, prompt.action_name)
-        end
-      end
-
-      def extract_content_from_delta(delta)
-        # Default extraction - override if needed
-        delta if delta.is_a?(String)
-      end
-
-      def handle_tool_stream_chunk(chunk, message, agent_stream)
-        # Handle tool calls in streaming
-        # Override in provider for specific implementation
-      end
-
-      def finalize_stream(message, agent_stream)
-        agent_stream&.call(message, nil, true, prompt.action_name)
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider/tool_management.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module GenerationProvider
-    module ToolManagement
-      extend ActiveSupport::Concern
-
-      def format_tools(tools)
-        return nil if tools.blank?
-
-        tools.map do |tool|
-          format_single_tool(tool)
-        end
-      end
-
-      def handle_actions(tool_calls)
-        return [] if tool_calls.nil? || tool_calls.empty?
-
-        tool_calls.map do |tool_call|
-          parse_tool_call(tool_call)
-        end.compact
-      end
-
-      protected
-
-      def format_single_tool(tool)
-        # Default implementation for OpenAI-style tools
-        if tool["function"] || tool[:function]
-          # Tool already has the correct structure
-          tool
-        else
-          # Legacy format - wrap in function structure
-          wrap_tool_in_function(tool)
-        end
-      end
-
-      def wrap_tool_in_function(tool)
-        {
-          type: "function",
-          function: {
-            name: tool["name"] || tool[:name],
-            description: tool["description"] || tool[:description],
-            parameters: tool["parameters"] || tool[:parameters]
-          }
-        }
-      end
-
-      def parse_tool_call(tool_call)
-        # Skip if no function information
-        return nil if tool_call.nil?
-
-        # Extract tool information based on provider format
-        tool_id = extract_tool_id(tool_call)
-        tool_name = extract_tool_name(tool_call)
-        tool_params = extract_tool_params(tool_call)
-
-        # Skip if no name found
-        return nil if tool_name.blank?
-
-        ActiveAgent::ActionPrompt::Action.new(
-          id: tool_id,
-          name: tool_name,
-          params: tool_params
-        )
-      end
-
-      def extract_tool_id(tool_call)
-        tool_call["id"] || tool_call[:id]
-      end
-
-      def extract_tool_name(tool_call)
-        # Try different paths for tool name
-        tool_call.dig("function", "name") ||
-          tool_call.dig(:function, :name) ||
-          tool_call["name"] ||
-          tool_call[:name]
-      end
-
-      def extract_tool_params(tool_call)
-        # Try different paths for tool parameters/arguments
-        args = tool_call.dig("function", "arguments") ||
-               tool_call.dig(:function, :arguments) ||
-               tool_call["arguments"] ||
-               tool_call[:arguments] ||
-               tool_call["input"] ||
-               tool_call[:input]
-
-        return nil if args.blank?
-
-        # Parse JSON string if needed
-        if args.is_a?(String)
-          begin
-            JSON.parse(args, symbolize_names: true)
-          rescue JSON::ParserError
-            nil
-          end
-        else
-          args
-        end
-      end
-
-      # Provider-specific tool format methods
-      # Override these in specific providers
-
-      def format_tools_for_anthropic(tools)
-        # Anthropic-specific tool format
-        tools.map do |tool|
-          {
-            name: extract_tool_name_from_schema(tool),
-            description: extract_tool_description_from_schema(tool),
-            input_schema: extract_tool_parameters_from_schema(tool)
-          }
-        end
-      end
-
-      def format_tools_for_openai(tools)
-        # OpenAI-specific tool format (default)
-        format_tools(tools)
-      end
-
-      private
-
-      def extract_tool_name_from_schema(tool)
-        tool["name"] || tool[:name] ||
-        tool.dig("function", "name") || tool.dig(:function, "name") ||
-        tool.dig("function", :name) || tool.dig(:function, :name)
-      end
-
-      def extract_tool_description_from_schema(tool)
-        tool["description"] || tool[:description] ||
-        tool.dig("function", "description") || tool.dig(:function, "description") ||
-        tool.dig("function", :description) || tool.dig(:function, :description)
-      end
-
-      def extract_tool_parameters_from_schema(tool)
-        tool["parameters"] || tool[:parameters] ||
-        tool.dig("function", "parameters") || tool.dig(:function, "parameters") ||
-        tool.dig("function", :parameters) || tool.dig(:function, :parameters)
-      end
-    end
-  end
-end

data/lib/active_agent/generation_provider.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module GenerationProvider
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_generation_provider_name, instance_accessor: false, instance_predicate: false
-      class_attribute :_generation_provider, instance_accessor: false, instance_predicate: false
-
-      delegate :generation_provider, to: :class
-    end
-
-    module ClassMethods
-      def configuration(name_or_provider, **options)
-        config = ActiveAgent.config[name_or_provider.to_s] || ActiveAgent.config.dig(ENV["RAILS_ENV"], name_or_provider.to_s) || {}
-        config = { "service" => "OpenAI" } if config.empty? && name_or_provider == :openai
-        config.merge!(options)
-      raise "Failed to load provider #{name_or_provider}: configuration not found for provider"  if config["service"].nil?
-        configure_provider(config)
-      rescue LoadError => e
-        raise RuntimeError, "Failed to load provider #{name_or_provider}: #{e.message}"
-      end
-
-      def configure_provider(config)
-        service_name = config["service"]
-        require "active_agent/generation_provider/#{service_name.underscore}_provider"
-
-        ActiveAgent::GenerationProvider.const_get("#{service_name.camelize}Provider").new(config)
-      end
-
-      def generation_provider
-        self.generation_provider = :openai if _generation_provider.nil?
-        _generation_provider
-      end
-
-      def generation_provider_name
-        self.generation_provider = :openai if _generation_provider_name.nil?
-        _generation_provider_name
-      end
-
-      def generation_provider=(name_or_provider)
-        case name_or_provider
-        when Symbol, String
-          provider = configuration(name_or_provider)
-          assign_provider(name_or_provider.to_s, provider)
-        when OpenAI::Client
-          name = :openai
-          assign_provider(name, name_or_provider)
-        else
-          raise ArgumentError
-        end
-      end
-
-      private
-
-      def assign_provider(provider_name, generation_provider)
-        self._generation_provider_name = provider_name
-        self._generation_provider = generation_provider
-      end
-    end
-
-    def generation_provider
-      self.class.generation_provider
-    end
-  end
-end

data/lib/active_agent/log_subscriber.rb

@@ -1,44 +0,0 @@
-# # frozen_string_literal: true
-
-# require "active_support/log_subscriber"
-
-# module ActiveAgent
-#   # = Active Agent \LogSubscriber
-#   #
-#   # Implements the ActiveSupport::LogSubscriber for logging notifications when
-#   # prompt is generated.
-#   class LogSubscriber < ActiveSupport::LogSubscriber
-#     # A prompt was generated.
-#     def deliver(event)
-#       info do
-#         if exception = event.payload[:exception_object]
-#           "Failed delivery of prompt #{event.payload[:message_id]} error_class=#{exception.class} error_message=#{exception.message.inspect}"
-#         elsif event.payload[:perform_deliveries]
-#           "Generated response for prompt #{event.payload[:message_id]} (#{event.duration.round(1)}ms)"
-#         else
-#           "Skipped generation of prompt #{event.payload[:message_id]} as `perform_generation` is false"
-#         end
-#       end
-
-#       debug { event.payload[:prompt] }
-#     end
-#     subscribe_log_level :deliver, :debug
-
-#     # A prompt was rendered.
-#     def process(event)
-#       debug do
-#         agent = event.payload[:agent]
-#         action = event.payload[:action]
-#         "#{agent}##{action}: processed outbound prompt in #{event.duration.round(1)}ms"
-#       end
-#     end
-#     subscribe_log_level :process, :debug
-
-#     # Use the logger configured for ActiveAgent::Base.
-#     def logger
-#       ActiveAgent::Base.logger
-#     end
-#   end
-# end
-
-# ActiveAgent::LogSubscriber.attach_to :active_agent

data/lib/active_agent/parameterized.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Parameterized
-    extend ActiveSupport::Concern
-
-    included do
-      attr_writer :params
-
-      def params
-        @params ||= {}
-      end
-    end
-
-    module ClassMethods
-      def with(params = {})
-        # Separate runtime options from regular params
-        # runtime_options = params.extract!(:model, :temperature, :max_tokens, :stream, :top_p,
-        #                                   :frequency_penalty, :presence_penalty, :response_format,
-        #                                   :seed, :stop, :tools_choice, :user)
-
-        # # Pass runtime options as :options parameter
-        # params[:options] = runtime_options if runtime_options.any?
-
-        ActiveAgent::Parameterized::Agent.new(self, params)
-      end
-      alias_method :prompt_with, :with
-    end
-
-    class Agent
-      def initialize(agent, params)
-        @agent = agent
-        @params = params
-      end
-
-      def method_missing(method_name, ...)
-        if @agent.public_instance_methods.include?(method_name)
-          ActiveAgent::Parameterized::Generation.new(@agent, method_name, @params, ...)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method, include_all = false)
-        @agent.respond_to?(method, include_all)
-      end
-    end
-
-    class Generation < ActiveAgent::Generation
-      def initialize(agent_class, action, params, ...)
-        super(agent_class, action, ...)
-        @params = params
-      end
-
-      private
-
-      def processed_agent
-        @processed_agent ||= @agent_class.new.tap do |agent|
-          agent.params = @params
-          agent.process @action, *@args
-        end
-      end
-
-      def enqueue_generation(generation_method, options = {})
-        if processed?
-          super
-        else
-          @agent_class.generation_job.set(options).perform_later(
-            @agent_class.name, @action.to_s, generation_method.to_s, params: @params, args: @args
-          )
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/prompt_helper.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  # = Active Agent's Action Prompt \PromptHelper
-  #
-  # Provides helper methods for ActiveAgent::Base that can be used for easily
-  # formatting prompts, accessing agent or prompt instances.
-  module PromptHelper
-    # Access the agent instance.
-    def agent
-      @_controller
-    end
-
-    # Access the prompt instance.
-    def context
-      @_context
-    end
-  end
-end

data/lib/active_agent/queued_generation.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module QueuedGeneration
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :generation_job, default: ::ActiveAgent::GenerationJob
-      class_attribute :generate_later_queue_name, default: :agents
-    end
-  end
-end

data/lib/active_agent/rescuable.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent # :nodoc:
-  # = Active Agent \Rescuable
-  #
-  # Provides
-  # {rescue_from}[rdoc-ref:ActiveSupport::Rescuable::ClassMethods#rescue_from]
-  # for agents. Wraps agent action processing, generation job processing, and prompt
-  # generation to handle configured errors.
-  module Rescuable
-    extend ActiveSupport::Concern
-    include ActiveSupport::Rescuable
-
-    class_methods do
-      def handle_exception(exception) # :nodoc:
-        rescue_with_handler(exception) || raise(exception)
-      end
-    end
-
-    def handle_exceptions # :nodoc:
-      yield
-    rescue => exception
-      rescue_with_handler(exception) || raise
-    end
-
-    private
-
-    def process(...)
-      handle_exceptions do
-        super
-      end
-    end
-  end
-end