activeagent 1.9.1 → 1.9.3

data/lib/active_agent/providers/common/usage.rb

@@ -335,8 +335,10 @@ module ActiveAgent
           # Detect Ollama by presence of nanosecond duration fields
           if usage.key?(:total_duration)
             from_ollama(usage_hash)
-          # Detect Anthropic by presence of cache_creation or service_tier
-          elsif usage.key?(:cache_creation) || usage.key?(:service_tier)
+          # Detect Anthropic by presence of cache_creation or service_tier, or by its
+          # cache token fields (a usage payload does not always carry the former two)
+          elsif usage.key?(:cache_creation) || usage.key?(:service_tier) ||
+                usage.key?(:cache_read_input_tokens) || usage.key?(:cache_creation_input_tokens)
             from_anthropic(usage_hash)
           # Detect OpenAI Responses API by input_tokens/output_tokens with details
           elsif usage.key?(:input_tokens) && usage.key?(:input_tokens_details)

data/lib/active_agent/providers/open_ai/chat_provider.rb

@@ -117,6 +117,10 @@ module ActiveAgent
             return if api_message.nil?
 
             # If we have a delta, we need to update a message in the stack
+            if (finish_reason = api_message.try(:finish_reason))
+              self.stream_finish_reason = finish_reason.to_s
+            end
+
             message = find_or_create_message(api_message.index)
             message_merge_delta(message, api_message.delta.deep_to_h)
 
@@ -143,6 +147,13 @@ module ActiveAgent
             # => {type: :"tool_calls.function.arguments.delta", name: "get_current_weather", index: 0, arguments: "", parsed: nil, arguments_delta: ""}
           when :"tool_calls.function.arguments.done"
             # => => {type: :"tool_calls.function.arguments.done", index: 0, name: "get_current_weather", arguments: "{\"location\":\"Boston, MA\"}", parsed: nil}
+          when :"refusal.delta"
+            # No-Op; the refusal is merged into the message from the :chunk event
+          when :"refusal.done"
+            # A refused message ends here, with no content.done
+            self.stream_completion_pending = true
+          when :"logprobs.content.delta", :"logprobs.content.done", :"logprobs.refusal.delta", :"logprobs.refusal.done"
+            # No-Op; sent when the request asks for logprobs
           else
             fail "Unexpected Response Event Type: #{api_response_event.type}"
           end
@@ -256,6 +267,39 @@ module ActiveAgent
           message_stack.last
         end
 
+        # Finds the streamed tool call an unindexed delta continues
+        #
+        # OpenAI-compatible servers (Gemini's compatibility endpoint, some Ollama
+        # and OpenRouter backends) omit the `index` that ties argument fragments
+        # to their call. A delta carrying an `id` continues the call with that
+        # id; one without an id or a function name continues the last call;
+        # anything else starts a new call.
+        #
+        # @param tool_calls [Array<Hash>] calls accumulated so far
+        # @param delta_item [Hash] unindexed tool call delta
+        # @return [Hash, nil] the call to merge into, or nil for a new call
+        def unindexed_tool_call_target(tool_calls, delta_item)
+          if delta_item[:id].present?
+            tool_calls.find { _1[:id] == delta_item[:id] }
+          elsif delta_item.dig(:function, :name).blank?
+            tool_calls.last
+          end
+        end
+
+        # Strips the fields a server repeats on every fragment (`id`, `type`,
+        # the function name), so merging does not concatenate them.
+        #
+        # @param hash_item [Hash] the call the fragment continues
+        # @param delta_item [Hash] unindexed tool call delta
+        # @return [Hash] the fragment to merge
+        def unindexed_tool_call_fragment(hash_item, delta_item)
+          fragment = delta_item.except(:id, :type)
+          if fragment[:function].is_a?(Hash) && fragment.dig(:function, :name) == hash_item.dig(:function, :name)
+            fragment = fragment.merge(function: fragment[:function].except(:name))
+          end
+          fragment
+        end
+
         # Recursively merges delta changes into a hash structure
         #
         # Handles complex delta merging for OpenAI's streaming API, including
@@ -278,6 +322,8 @@ module ActiveAgent
                   else
                     hash[key] << delta_item
                   end
+                elsif key == :tool_calls && delta_item.is_a?(Hash) && (hash_item = unindexed_tool_call_target(hash[key], delta_item))
+                  hash_merge_delta(hash_item, unindexed_tool_call_fragment(hash_item, delta_item))
                 else
                   hash[key] << delta_item
                 end

data/lib/active_agent/providers/open_ai/responses_provider.rb

@@ -15,6 +15,18 @@ module ActiveAgent
       class ResponsesProvider < Base
         include ToolChoiceClearing
 
+        # Output items of OpenAI's built-in tools (web search, file search,
+        # image generation, code interpreter, remote MCP).
+        BUILT_IN_TOOL_ITEM_TYPES = %i[
+          web_search_call file_search_call image_generation_call code_interpreter_call mcp_call mcp_list_tools
+        ].freeze
+
+        # Prefixes of the progress events those tools stream.
+        BUILT_IN_TOOL_EVENT_PREFIXES = %w[
+          response.web_search_call. response.file_search_call. response.image_generation_call.
+          response.code_interpreter_call response.mcp_call response.mcp_list_tools.
+        ].freeze
+
         # @return [Class]
         def self.options_klass
           Options
@@ -99,6 +111,7 @@ module ActiveAgent
         # - `:"response.content_part.done"` - content part completed
         # - `:"response.output_item.done"` - message, reasoning or function call completed
         # - `:"response.completed"` - response finished
+        # - `:"response.incomplete"` - response cut short (e.g. max_output_tokens)
         #
         # @param api_response_event [Hash] streaming chunk with :type key
         # @return [void]
@@ -106,6 +119,12 @@ module ActiveAgent
         def process_stream_chunk(api_response_event)
           instrument("stream_chunk.active_agent", chunk_type: api_response_event.type)
 
+          # Built-in tools report their progress with their own events; the
+          # finished tool call arrives as an output item.
+          if BUILT_IN_TOOL_EVENT_PREFIXES.any? { api_response_event.type.to_s.start_with?(_1) }
+            return
+          end
+
           case api_response_event.type
           # Response Created
           when :"response.created", :"response.in_progress"
@@ -124,12 +143,20 @@ module ActiveAgent
             message[:content] += api_response_event.delta
             broadcast_stream_update(message, api_response_event.delta)
 
+          # -> -> -> Content Text Citation (e.g. from web search)
+          when :"response.output_text.annotation.added"
+          # No-Op: The text is complete at response.output_text.done
+
           # -> -> -> Content Text Completed [Full Text]
           when :"response.output_text.done"
             message = message_stack.find { _1[:id] == api_response_event.item_id }
             message[:content] = api_response_event.text
             broadcast_stream_update(message, nil) # Don't double send content
 
+          # -> -> -> Refusal (the response still ends with response.completed)
+          when :"response.refusal.delta", :"response.refusal.done"
+          # No-Op: The message has no refusal field to stream it into
+
           # -> -> -> Content Function Call Append
           when :"response.function_call_arguments.delta", :"response.function_call_arguments.done"
           # No-Op: Wait for FC to Land
@@ -147,8 +174,16 @@ module ActiveAgent
           when :"response.output_item.done"
             process_stream_output_item_done(api_response_event)
 
-          # Response Completed
-          when :"response.completed"
+          # Response Completed, or cut short (e.g. by max_output_tokens) with
+          # the output it has so far
+          when :"response.completed", :"response.incomplete"
+            # The streamed response carries no body for resolve_prompt to read
+            # usage from, so it is recorded from the final event.
+            record_stream_usage(api_response_event.response.usage)
+
+            response = api_response_event.response
+            self.stream_finish_reason = (response.incomplete_details&.reason || response.status).to_s
+
             # Completion, tool loop included, runs from stream_finished! once
             # the stream has drained, so each turn's tool calls run once.
             self.stream_completion_pending = true
@@ -174,7 +209,7 @@ module ActiveAgent
             # PATCH: API returns an empty array instead of empty string due to a bug in their serialization
             item_hash = Responses::Transforms.gem_to_hash(api_response_event.item).compact_blank
             message_stack << { content: "" }.merge(item_hash)
-          when :function_call, :reasoning
+          when :function_call, :reasoning, *BUILT_IN_TOOL_ITEM_TYPES
             # No-Op: Wait for the item to land (-> response.output_item.done)
           else
             raise "Unexpected Item Type: #{api_response_event.item.type}"
@@ -194,7 +229,8 @@ module ActiveAgent
           case api_response_event.item.type
           when :message
             # No-Op: Message Up to Date
-          when :function_call, :reasoning
+          when :function_call, :reasoning, *BUILT_IN_TOOL_ITEM_TYPES
+            # Kept like the non-streamed output, which holds every item
             item_hash = Responses::Transforms.gem_to_hash(api_response_event.item)
             message_stack << item_hash
           else

data/lib/active_agent/providers/opper/_types.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/chat/_types"
+require_relative "options"
+
+module ActiveAgent
+  module Providers
+    module Opper
+      # ActiveModel type for casting and serializing Opper requests.
+      #
+      # Opper is OpenAI-compatible, so requests use the same shape as the
+      # OpenAI Chat API. This delegates entirely to OpenAI::Chat::RequestType.
+      RequestType = ActiveAgent::Providers::OpenAI::Chat::RequestType
+    end
+  end
+end

data/lib/active_agent/providers/opper/options.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module Opper
+      # Configuration options for the Opper provider.
+      #
+      # Extends OpenAI::Options, overriding the base URL to point at Opper's
+      # OpenAI-compatible gateway and resolving the API key from OPPER_API_KEY.
+      # Opper does not use organization or project identifiers.
+      #
+      # @example Basic configuration
+      #   options = Options.new(api_key: ENV["OPPER_API_KEY"])
+      #
+      # @see https://docs.opper.ai
+      # @see https://platform.opper.ai Opper API Keys
+      class Options < ActiveAgent::Providers::OpenAI::Options
+        # @!attribute base_url
+        #   @return [String] API endpoint (default: "https://api.opper.ai/v3/compat")
+        attribute :base_url, :string, as: "https://api.opper.ai/v3/compat"
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["OPPER_API_KEY"]
+        end
+
+        # Not used as part of Opper
+        def resolve_organization_id(kwargs) = nil
+        def resolve_project_id(kwargs)      = nil
+      end
+    end
+  end
+end

data/lib/active_agent/providers/opper_provider.rb

@@ -0,0 +1,72 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "opper/_types"
+
+module ActiveAgent
+  module Providers
+    # Provides access to Opper's OpenAI-compatible LLM gateway.
+    #
+    # Extends the OpenAI provider to work with Opper's OpenAI-compatible API,
+    # enabling access to models from many providers through a single
+    # interface. Model ids are bare pool names (e.g. +claude-sonnet-4-6+);
+    # a +provider/model+ id (e.g. +anthropic/claude-sonnet-4-6+) pins a route.
+    #
+    # Opper is a plain OpenAI-compatible gateway: requests, responses and
+    # transforms are identical to the OpenAI Chat API, so this provider reuses
+    # OpenAI::Chat::RequestType and OpenAI::Chat::Transforms directly. The only
+    # Opper-specific configuration is the base URL and API key, which live in
+    # Opper::Options.
+    #
+    # @example Configuration in active_agent.yml
+    #   opper:
+    #     service: "Opper"
+    #     api_key: <%= ENV["OPPER_API_KEY"] %>
+    #     model: "claude-sonnet-4-6"
+    #
+    # @see OpenAI::ChatProvider
+    # @see https://docs.opper.ai
+    class OpperProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "Opper"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        Opper::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        OpenAI::Chat::RequestType.new
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.embed_request_type
+        OpenAI::Embedding::RequestType.new
+      end
+
+      protected
+
+      # Executes an embedding request via Opper's OpenAI-compatible API.
+      #
+      # @param parameters [Hash]
+      # @return [Hash] symbolized API response
+      def api_embed_execute(parameters)
+        client.embeddings.create(**parameters).as_json.deep_symbolize_keys
+      end
+
+      # @see BaseProvider#api_response_normalize
+      # @param api_response [OpenAI::Models::ChatCompletion]
+      # @return [Hash] normalized response hash
+      def api_response_normalize(api_response)
+        return api_response unless api_response
+
+        OpenAI::Chat::Transforms.gem_to_hash(api_response)
+      end
+    end
+  end
+end

data/lib/active_agent/schema_generator.rb

@@ -34,6 +34,21 @@ module ActiveAgent
   #
   #   ContactForm.to_json_schema
   #
+  # @example ActiveModel with a nested array of objects
+  #   class Person
+  #     include ActiveModel::Model
+  #     include ActiveModel::Attributes
+  #     include ActiveAgent::SchemaGenerator
+  #
+  #     attribute :name, :string
+  #     has_many :addresses, class_name: "Address"
+  #   end
+  #
+  #   Person.to_json_schema
+  #   # => { name: "person", schema: { type: "object", properties: {
+  #   #      name: {...}, addresses: { type: "array", items: { "$ref": "#/$defs/address" } } },
+  #   #      ..., "$defs": { address: { type: "object", ... } } } }
+  #
   # @see Builder
   module SchemaGenerator
     extend ActiveSupport::Concern
@@ -47,6 +62,13 @@ module ActiveAgent
         # Fallback for any class that includes this module
         extend ActiveModelClassMethods
       end
+
+      # The railtie includes this module into ActiveRecord::Base too, whose
+      # has_many must stay ActiveRecord's.
+      unless respond_to?(:has_many)
+        extend ActiveModelAssociations
+        class_attribute :schema_associations, instance_accessor: false, default: {}.freeze
+      end
     end
 
     # Class methods added to ActiveRecord models.
@@ -106,6 +128,40 @@ module ActiveAgent
       end
     end
 
+    # Nested schemas for ActiveModel classes, which have no associations of
+    # their own. Added only to a class without a +has_many+ already.
+    module ActiveModelAssociations
+      # Declares an array of objects described by another schema class.
+      #
+      # {ActiveModelClassMethods#to_json_schema} emits the attribute as an
+      # array whose items are a +$ref+ to that class's schema, which goes under
+      # the root +$defs+ keyed by the singular name in lower camel case
+      # (+addresses+ becomes +address+, +line_items+ becomes +lineItem+).
+      # The prompt preserves both property and definition names.
+      #
+      # Also declares the attribute, defaulting to an empty array, so the
+      # model accepts the data the schema describes.
+      #
+      # @param name [Symbol] the attribute holding the array
+      # @param class_name [String] full constant name of the item class, which
+      #   generates JSON Schema too; resolved when the schema is generated
+      # @return [void]
+      # @raise [ArgumentError] when the class does not include
+      #   +ActiveModel::Attributes+, which declares the attribute
+      #
+      # @example
+      #   has_many :addresses, class_name: "Address"
+      def has_many(name, class_name:)
+        unless respond_to?(:attribute)
+          raise ArgumentError, "#{self.name || inspect}.has_many :#{name} needs ActiveModel::Attributes to declare the attribute; include it before calling has_many"
+        end
+
+        self.schema_associations = schema_associations.merge(name.to_sym => class_name).freeze
+
+        attribute name, default: -> { [] }
+      end
+    end
+
     # Internal builder class for constructing JSON Schemas from model classes.
     #
     # This class handles the actual schema generation logic, supporting both
@@ -122,24 +178,7 @@ module ActiveAgent
       #
       # @raise [ArgumentError] If model_class is not an ActiveRecord or ActiveModel class
       def self.json_schema_from_model(model_class, options = {})
-        schema = {
-          type: "object",
-          properties: {},
-          required: [],
-          additional_properties: options.fetch(:additional_properties, false)
-        }
-
-        if defined?(ActiveRecord::Base) && model_class < ActiveRecord::Base
-          schema = build_activerecord_schema(schema, model_class, options)
-        elsif defined?(ActiveModel::Model) && model_class.include?(ActiveModel::Model)
-          schema = build_activemodel_schema(schema, model_class, options)
-        else
-          raise ArgumentError, "Model must be an ActiveRecord or ActiveModel class"
-        end
-
-        # OpenAI strict mode requires all properties to be in the required array
-        # So we add all properties to required if strict mode is enabled
-        schema[:required] = schema[:properties].keys.sort if options[:strict]
+        schema = object_schema(model_class, options)
 
         {
           name: options[:name] || model_class.name.underscore,
@@ -151,6 +190,37 @@ module ActiveAgent
       class << self
         private
 
+        # Builds the object schema of a model class, without the name and
+        # strict flag {json_schema_from_model} wraps it in.
+        #
+        # @param model_class [Class] The ActiveRecord or ActiveModel class
+        # @param options [Hash] Schema generation options
+        # @param ancestors [Array<Class>] the classes nesting this one, outermost first
+        #
+        # @return [Hash] The object schema
+        def object_schema(model_class, options, ancestors = [])
+          schema = {
+            type: "object",
+            properties: {},
+            required: [],
+            additional_properties: options.fetch(:additional_properties, false)
+          }
+
+          if defined?(ActiveRecord::Base) && model_class < ActiveRecord::Base
+            schema = build_activerecord_schema(schema, model_class, options)
+          elsif defined?(ActiveModel::Model) && model_class.include?(ActiveModel::Model)
+            schema = build_activemodel_schema(schema, model_class, options, ancestors)
+          else
+            raise ArgumentError, "Model must be an ActiveRecord or ActiveModel class"
+          end
+
+          # OpenAI strict mode requires all properties to be in the required array
+          # So we add all properties to required if strict mode is enabled
+          schema[:required] = schema[:properties].keys.sort if options[:strict]
+
+          schema
+        end
+
         # Builds a JSON Schema from an ActiveRecord model.
         #
         # Extracts column information, associations, and validations to build
@@ -187,14 +257,16 @@ module ActiveAgent
 
         # Builds a JSON Schema from an ActiveModel class.
         #
-        # Extracts attribute types and validations to build a schema representation.
+        # Extracts attribute types, nested schemas and validations to build a
+        # schema representation.
         #
         # @param schema [Hash] The schema hash to populate
         # @param model_class [Class] The ActiveModel class
         # @param options [Hash] Schema generation options
+        # @param ancestors [Array<Class>] the classes nesting this one, outermost first
         #
         # @return [void]
-        def build_activemodel_schema(schema, model_class, options)
+        def build_activemodel_schema(schema, model_class, options, ancestors)
           if model_class.respond_to?(:attribute_types)
             model_class.attribute_types.each do |name, type|
               next if options[:exclude]&.include?(name.to_sym)
@@ -206,6 +278,10 @@ module ActiveAgent
             raise ArgumentError, "#{model_class.name} does not define any attributes. Use `attribute :name, :type` to define attributes."
           end
 
+          if model_class.respond_to?(:schema_associations)
+            schema = add_activemodel_associations_to_schema(schema, model_class, options, ancestors)
+          end
+
           if model_class.respond_to?(:validators)
             schema = add_validations_to_schema(schema, model_class, options)
           end
@@ -356,6 +432,51 @@ module ActiveAgent
           schema
         end
 
+        # Adds the arrays an ActiveModel class declares with
+        # {ActiveModelAssociations#has_many}, each item a +$ref+ to the nested
+        # class's schema under +$defs+.
+        #
+        # A +$ref+ resolves against the root of the schema, so the definitions
+        # a nested class collects move up into this schema's +$defs+.
+        #
+        # @param schema [Hash] The schema hash to populate
+        # @param model_class [Class] The ActiveModel class
+        # @param options [Hash] Schema generation options
+        # @param ancestors [Array<Class>] the classes nesting this one, outermost first
+        #
+        # @return [Hash]
+        # @raise [ArgumentError] when a class nests itself, or two different
+        #   schemas would share a definition name
+        def add_activemodel_associations_to_schema(schema, model_class, options, ancestors)
+          path        = ancestors + [ model_class ]
+          definitions = {}
+
+          model_class.schema_associations.each do |name, class_name|
+            next if options[:exclude]&.include?(name)
+
+            nested_class = class_name.constantize
+            if path.include?(nested_class)
+              raise ArgumentError, "#{model_class.name}.has_many :#{name} is recursive (#{(path + [ nested_class ]).map(&:name).join(' > ')}); recursive schemas are not supported"
+            end
+
+            key    = name.to_s.singularize.camelize(:lower).to_sym
+            nested = object_schema(nested_class, options.slice(:strict, :additional_properties), path)
+
+            [ [ key, nested ], *nested.delete(:$defs) ].each do |definition_key, definition|
+              if definitions.key?(definition_key) && definitions[definition_key] != definition
+                raise ArgumentError, "#{model_class.name} nests two different schemas under the definition #{definition_key.inspect}"
+              end
+
+              definitions[definition_key] = definition
+            end
+
+            schema[:properties][name] = { type: "array", items: { "$ref": "#/$defs/#{key}" } }
+          end
+
+          schema[:$defs] = definitions if definitions.any?
+          schema
+        end
+
         # Adds validation constraints to the schema.
         #
         # Translates ActiveModel validations (presence, length, numericality,
@@ -375,11 +496,14 @@ module ActiveAgent
               when ActiveModel::Validations::PresenceValidator
                 schema[:required] << attribute.to_sym unless schema[:required].include?(attribute.to_sym)
               when ActiveModel::Validations::LengthValidator
+                # An array, such as a has_many, is limited by its item count.
+                min_key, max_key = schema[:properties][attribute.to_sym][:type] == "array" ? [ :min_items, :max_items ] : [ :min_length, :max_length ]
+
                 if validator.options[:minimum]
-                  schema[:properties][attribute.to_sym][:min_length] = validator.options[:minimum]
+                  schema[:properties][attribute.to_sym][min_key] = validator.options[:minimum]
                 end
                 if validator.options[:maximum]
-                  schema[:properties][attribute.to_sym][:max_length] = validator.options[:maximum]
+                  schema[:properties][attribute.to_sym][max_key] = validator.options[:maximum]
                 end
               when ActiveModel::Validations::NumericalityValidator
                 if validator.options[:greater_than]

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "1.9.1"
+  VERSION = "1.9.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.9.3
 platform: ruby
 authors:
 - Justin Bowen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-17 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -456,6 +456,7 @@ files:
 - lib/active_agent/deprecator.rb
 - lib/active_agent/evals.rb
 - lib/active_agent/evals/catalog.rb
+- lib/active_agent/evals/comparison.rb
 - lib/active_agent/evals/correlation.rb
 - lib/active_agent/evals/design_tokens.rb
 - lib/active_agent/evals/diagnosis.rb
@@ -466,12 +467,14 @@ files:
 - lib/active_agent/evals/replay.rb
 - lib/active_agent/evals/report.rb
 - lib/active_agent/evals/report_html.rb
+- lib/active_agent/evals/report_markdown.rb
 - lib/active_agent/evals/result.rb
 - lib/active_agent/evals/ruby_llm.rb
 - lib/active_agent/evals/runner.rb
 - lib/active_agent/evals/scenario.rb
 - lib/active_agent/evals/scenario_parser.rb
 - lib/active_agent/evals/scorer.rb
+- lib/active_agent/evals/statistics.rb
 - lib/active_agent/evals/suite.rb
 - lib/active_agent/generation.rb
 - lib/active_agent/generation_job.rb
@@ -583,6 +586,9 @@ files:
 - lib/active_agent/providers/open_router_provider.rb
 - lib/active_agent/providers/openai_provider.rb
 - lib/active_agent/providers/openrouter_provider.rb
+- lib/active_agent/providers/opper/_types.rb
+- lib/active_agent/providers/opper/options.rb
+- lib/active_agent/providers/opper_provider.rb
 - lib/active_agent/providers/requesty/_types.rb
 - lib/active_agent/providers/requesty/options.rb
 - lib/active_agent/providers/requesty_provider.rb