riffer 0.52.1 → 0.54.0

data/lib/riffer/params/format.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "date"
+require "ipaddr"
+
+module Riffer::Params::Format
+  extend self
+
+  DATE = /\A(\d{4})-(\d{2})-(\d{2})\z/ #: Regexp
+
+  DATE_TIME = /\A(\d{4})-(\d{2})-(\d{2})[Tt]([01]\d|2[0-3]):[0-5]\d:([0-5]\d|60)(\.\d+)?([Zz]|[+-]([01]\d|2[0-3]):[0-5]\d)\z/ #: Regexp
+
+  # The offset is optional: Anthropic's grammar emits times without one.
+  TIME = /\A([01]\d|2[0-3]):[0-5]\d:([0-5]\d|60)(\.\d+)?([Zz]|[+-]([01]\d|2[0-3]):[0-5]\d)?\z/ #: Regexp
+
+  DURATION = /\AP(?!\z)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|\d+W)\z/ #: Regexp
+
+  UUID = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/ #: Regexp
+
+  # The WHATWG HTML pattern: no single pattern matches RFC 5322 exactly, so
+  # this one only rules out values that are clearly not an address.
+  EMAIL = %r{\A[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*\z} #: Regexp
+
+  HOSTNAME = /\A(?=.{1,253}\.?\z)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*\.?\z/ #: Regexp
+
+  # The formats OpenAI, Anthropic and Bedrock all accept. OpenAI rejects uri.
+  CHECKS = {
+    "date-time" => ->(value) { calendar_date?(DATE_TIME, value) },
+    "time" => ->(value) { TIME.match?(value) },
+    "date" => ->(value) { calendar_date?(DATE, value) },
+    "duration" => ->(value) { DURATION.match?(value) },
+    "email" => ->(value) { EMAIL.match?(value) },
+    "hostname" => ->(value) { HOSTNAME.match?(value) },
+    "ipv4" => ->(value) { ip_address?(value, &:ipv4?) },
+    "ipv6" => ->(value) { ip_address?(value, &:ipv6?) },
+    "uuid" => ->(value) { UUID.match?(value) },
+  }.freeze #: Hash[String, ^(String) -> bool]
+
+  private_constant :DATE, :DATE_TIME, :TIME, :DURATION, :UUID, :EMAIL, :HOSTNAME, :CHECKS
+
+  NAMES = CHECKS.keys.freeze #: Array[String]
+
+  #--
+  #: (String, String) -> bool
+  def valid?(format, value)
+    CHECKS.fetch(format).call(value)
+  end
+
+  private
+
+  #--
+  #: (Regexp, String) -> bool
+  def calendar_date?(pattern, value)
+    match = pattern.match(value)
+    return false unless match
+
+    # RFC 3339 dates are proleptic Gregorian; Date defaults to the Julian calendar before 1582.
+    Date.valid_date?(match[1].to_i, match[2].to_i, match[3].to_i, Date::GREGORIAN)
+  end
+
+  #--
+  #: (String) { (IPAddr) -> bool } -> bool
+  def ip_address?(value)
+    # IPAddr also accepts a prefix (10.0.0.0/24), a zone ID (fe80::1%eth0) and
+    # brackets ([::1]), none of which are part of an address.
+    return false if value.match?(%r{[/%\[\]]})
+
+    yield IPAddr.new(value)
+  rescue IPAddr::Error
+    false
+  end
+end

data/lib/riffer/params/param.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
+require "json"
+
 class Riffer::Params::Param
   TYPE_MAPPINGS = {
     String => "string",
@@ -34,43 +36,99 @@ class Riffer::Params::Param
 
   attr_reader :enum #: Array[untyped]? # @dynamic enum
 
+  attr_reader :format #: String? # @dynamic format
+
   attr_reader :default #: untyped # @dynamic default
 
   attr_reader :item_type #: Module? # @dynamic item_type
 
+  attr_reader :dimensions #: Integer # @dynamic dimensions
+
   attr_reader :nested_params #: Riffer::Params? # @dynamic nested_params
 
+  attr_reader :variants #: Array[Riffer::Params]? # @dynamic variants
+
   #--
   #: (Symbol, Hash[Symbol, untyped], required: bool) -> Riffer::Params::Param
   def self.from_json_schema(name, schema, required:)
-    ruby_type = json_type_to_ruby(schema[:type])
-    item_type, nested = resolve_nesting(ruby_type, schema)
+    variants = resolve_variants(schema[:anyOf]) if schema.key?(:anyOf)
+    ruby_type = variants ? Riffer::Params::AnyOf : json_type_to_ruby(schema[:type])
+    nested = resolve_nested_params(ruby_type, schema)
+    item_type, dimensions, items = resolve_typed_items(schema) if ruby_type == Array && !nested
 
     new(
       name: name,
       type: ruby_type,
       required: required,
       description: schema[:description],
-      enum: schema[:enum],
+      enum: schema[:enum] || items&.dig(:enum),
+      format: schema[:format] || items&.dig(:format),
       default: schema[:default],
       item_type: item_type,
+      dimensions: dimensions || 1,
       nested_params: nested,
+      variants: variants,
     )
   end
 
   #--
-  #: (Module, Hash[Symbol, untyped]) -> [Module?, Riffer::Params?]
-  def self.resolve_nesting(ruby_type, schema)
-    return [nil, Riffer::Params.from_json_schema(schema)] if ruby_type == Hash && schema[:properties]
-    return [nil, nil] unless ruby_type == Array
+  #: (Array[Hash[Symbol, untyped]]) -> Array[Riffer::Params]
+  def self.resolve_variants(branches)
+    # Strict schemas add a null branch to optional fields; nullability comes from +required+.
+    variants = branches.reject { |branch| branch[:type] == "null" }.map do |branch|
+      raise Riffer::ArgumentError, "Unsupported anyOf branch: #{branch.to_json}" unless branch[:type] == "object"
 
+      Riffer::Params.from_json_schema(branch)
+    end
+    raise Riffer::ArgumentError, "anyOf requires at least two object branches" if variants.size < 2
+
+    variants
+  end
+  private_class_method :resolve_variants
+
+  #--
+  #: (Module, Hash[Symbol, untyped]) -> Riffer::Params?
+  def self.resolve_nested_params(ruby_type, schema)
+    if ruby_type == Hash && schema[:properties]
+      Riffer::Params.from_json_schema(schema)
+    elsif ruby_type == Array && schema[:items].is_a?(Hash) && schema[:items][:properties]
+      Riffer::Params.from_json_schema(schema[:items])
+    end
+  end
+  private_class_method :resolve_nested_params
+
+  #--
+  #: (Hash[Symbol, untyped]) -> [Module, Integer, Hash[Symbol, untyped]]?
+  def self.resolve_typed_items(schema)
     items = schema[:items]
-    return [nil, nil] unless items.is_a?(Hash)
-    return [nil, Riffer::Params.from_json_schema(items)] if items[:properties]
+    return unless items.is_a?(Hash)
 
-    [json_type_to_ruby(items[:type]), nil]
+    dimensions = 1
+    # Riffer only writes nested arrays with enum/format and a single primitive type on the innermost
+    # items, and no nullable inner arrays; any other shape would read back with a different meaning.
+    while json_type_to_ruby(items[:type]) == Array
+      inner = items[:items]
+      unless items[:type] == "array" && inner.is_a?(Hash) && !items.keys.intersect?(%i[enum format])
+        raise Riffer::ArgumentError, "Unsupported nested array: #{items.to_json}"
+      end
+
+      items = inner
+      dimensions += 1
+    end
+
+    item_type = json_type_to_ruby(items[:type])
+    if dimensions > 1
+      if schema.keys.intersect?(%i[enum format])
+        raise Riffer::ArgumentError, "Unsupported nested array: #{schema.to_json}"
+      end
+      unless items[:type].is_a?(String) && PRIMITIVE_TYPES.include?(item_type)
+        raise Riffer::ArgumentError, "Unsupported nested array items: #{items.to_json}"
+      end
+    end
+
+    [item_type, dimensions, items]
   end
-  private_class_method :resolve_nesting
+  private_class_method :resolve_typed_items
 
   #--
   #: (untyped) -> Module
@@ -81,16 +139,27 @@ class Riffer::Params::Param
   private_class_method :json_type_to_ruby
 
   #--
-  #: (name: Symbol, type: Module, required: bool, ?description: String?, ?enum: Array[untyped]?, ?default: untyped, ?item_type: Module?, ?nested_params: Riffer::Params?) -> void
-  def initialize(name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil)
+  #: (name: Symbol, type: Module, required: bool, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?item_type: Module?, ?dimensions: Integer, ?nested_params: Riffer::Params?, ?variants: Array[Riffer::Params]?) -> void
+  def initialize(name:, type:, required:, description: nil, enum: nil, format: nil, default: nil, item_type: nil,
+                 dimensions: 1, nested_params: nil, variants: nil)
+    if type == Riffer::Params::AnyOf && variants.nil?
+      raise Riffer::ArgumentError, "#{name}: an AnyOf param requires variants"
+    end
+
     @name = name.to_sym
     @type = type
     @required = required
     @description = description
     @enum = enum
+    # Frozen and deduplicated, so copies never share a mutable string.
+    @format = format.is_a?(String) ? -format : format
     @default = default
     @item_type = item_type
+    @dimensions = dimensions
     @nested_params = nested_params
+    @variants = variants
+    # Checked here rather than in Params so from_json_schema enforces it too.
+    validate_format! if format
   end
 
   #--
@@ -102,6 +171,8 @@ class Riffer::Params::Param
       [true, false].include?(value)
     elsif type == Float
       value.is_a?(Numeric)
+    elsif type == Riffer::Params::AnyOf
+      value.is_a?(Hash)
     else
       value.is_a?(type)
     end
@@ -110,6 +181,8 @@ class Riffer::Params::Param
   #--
   #: () -> String
   def type_name
+    return "object" if type == Riffer::Params::AnyOf
+
     TYPE_MAPPINGS[type] || type.to_s.downcase
   end
 
@@ -120,9 +193,21 @@ class Riffer::Params::Param
     # Nullable so strict providers can distinguish absent from present.
     nullable = strict && !required
 
+    if type == Riffer::Params::AnyOf && variants
+      schema = { anyOf: variants.map { |variant| variant.to_json_schema(strict: strict) } } #: Hash[Symbol, untyped]
+      schema[:anyOf] << { type: "null" } if nullable
+      schema[:description] = description if description
+      schema[:default] = default unless strict || default.nil?
+      return schema
+    end
+
+    # A typed array's enum and format constrain its items, not the array.
+    value_enum = enum unless item_type
+    value_format = format unless item_type
+
     # Providers like Anthropic reject a nullable type union combined with enum.
-    if nullable && enum
-      schema = { anyOf: [{ type: type_name, enum: enum }, { type: "null" }] } #: Hash[Symbol, untyped]
+    if nullable && value_enum
+      schema = { anyOf: [{ type: type_name, enum: value_enum }, { type: "null" }] } #: Hash[Symbol, untyped]
       schema[:description] = description if description
       return schema
     end
@@ -132,7 +217,8 @@ class Riffer::Params::Param
 
     schema = { type: type } #: Hash[Symbol, untyped]
     schema[:description] = description if description
-    schema[:enum] = enum if enum
+    schema[:enum] = value_enum if value_enum
+    schema[:format] = value_format if value_format
     # Strict providers reject the +default+ keyword; emit it only in
     # non-strict mode, where it makes the schema a lossless round-trip
     # source for +from_json_schema+.
@@ -141,7 +227,9 @@ class Riffer::Params::Param
     if self.type == Array && nested_params
       schema[:items] = nested_params.to_json_schema(strict: strict)
     elsif self.type == Array && item_type
-      schema[:items] = { type: TYPE_MAPPINGS[item_type] }
+      items = { type: TYPE_MAPPINGS[item_type], enum: enum, format: format }.compact #: Hash[Symbol, untyped]
+      (dimensions - 1).times { items = { type: "array", items: items } }
+      schema[:items] = items
     elsif self.type == Hash && nested_params
       # The nested schema carries its own type: "object", which would clobber a nullable union.
       schema.merge!(nested_params.to_json_schema(strict: strict).except(:type))
@@ -160,10 +248,25 @@ class Riffer::Params::Param
   def initialize_copy(source)
     super
     @nested_params = source.nested_params&.dup
+    @variants = source.variants&.map(&:dup)
     @enum = Riffer::Helpers::DeepDup.call(source.enum)
     @default = Riffer::Helpers::DeepDup.call(source.default)
   end
 
+  #--
+  #: () -> void
+  def validate_format!
+    unless Riffer::Params::Format::NAMES.include?(format)
+      raise Riffer::ArgumentError,
+            "#{name}: format: must be a supported format (#{Riffer::Params::Format::NAMES.join(', ')}), " \
+            "got #{format.inspect}"
+    end
+    unless type == String || (type == Array && item_type == String)
+      raise Riffer::ArgumentError, "#{name}: format: requires a String or an Array whose innermost type is String"
+    end
+    raise Riffer::ArgumentError, "#{name}: format: cannot be used with enum:" if enum
+  end
+
   #--
   #: () -> void
   def validate_strict_shape!

data/lib/riffer/params.rb

@@ -29,33 +29,45 @@ class Riffer::Params
   end
 
   #--
-  #: (Symbol, Module, ?description: String?, ?enum: Array[untyped]?, ?of: Module?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
-  def required(name, type, description: nil, enum: nil, of: nil, &)
-    nested = build_nested(type, of, &)
+  #: (Symbol, singleton(Riffer::Params::AnyOf), ?description: String?) { (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> void
+  #: (Symbol, Module, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?of: (Module | Array[untyped])?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
+  def required(name, type, description: nil, enum: nil, format: nil, of: nil, &)
+    item_type, dimensions = unwrap_of(of)
+    nested = build_nested(type, item_type, enum, &) unless type == Riffer::Params::AnyOf
+    variants = build_variants(of, enum, &) if type == Riffer::Params::AnyOf
     @parameters << Riffer::Params::Param.new(
       name: name,
       type: type,
       required: true,
       description: description,
       enum: enum,
-      item_type: of,
+      format: format,
+      item_type: item_type,
+      dimensions: dimensions,
       nested_params: nested,
+      variants: variants,
     )
   end
 
   #--
-  #: (Symbol, Module, ?description: String?, ?enum: Array[untyped]?, ?default: untyped, ?of: Module?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
-  def optional(name, type, description: nil, enum: nil, default: nil, of: nil, &)
-    nested = build_nested(type, of, &)
+  #: (Symbol, singleton(Riffer::Params::AnyOf), ?description: String?, ?default: untyped) { (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> void
+  #: (Symbol, Module, ?description: String?, ?enum: Array[untyped]?, ?format: String?, ?default: untyped, ?of: (Module | Array[untyped])?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> void
+  def optional(name, type, description: nil, enum: nil, format: nil, default: nil, of: nil, &)
+    item_type, dimensions = unwrap_of(of)
+    nested = build_nested(type, item_type, enum, &) unless type == Riffer::Params::AnyOf
+    variants = build_variants(of, enum, &) if type == Riffer::Params::AnyOf
     @parameters << Riffer::Params::Param.new(
       name: name,
       type: type,
       required: false,
       description: description,
       enum: enum,
+      format: format,
       default: default,
-      item_type: of,
+      item_type: item_type,
+      dimensions: dimensions,
       nested_params: nested,
+      variants: variants,
     )
   end
 
@@ -83,11 +95,17 @@ class Riffer::Params
         next
       end
 
-      if param.enum && !param.enum.include?(value)
+      # A typed array's enum and format constrain its items, which validate_typed_array checks.
+      if param.enum && !param.item_type && !param.enum.include?(value)
         errors << "#{param.name} must be one of: #{param.enum.join(', ')}"
         next
       end
 
+      if param.format && !param.item_type && !Riffer::Params::Format.valid?(param.format, value)
+        errors << "#{param.name} must be a valid #{param.format}"
+        next
+      end
+
       value = validate_nested(param, value, errors)
 
       validated[param.name] = coerce_value(param.type, value)
@@ -131,9 +149,20 @@ class Riffer::Params
   end
 
   #--
-  #: (Module, Module?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
-  def build_nested(type, of, &block)
+  #: ((Module | Array[untyped])?, ?Integer) -> [Module?, Integer]
+  def unwrap_of(of, dimensions = 1)
+    return [of, dimensions] unless of.is_a?(Array)
+    raise Riffer::ArgumentError, "of: must nest exactly one type, got #{of.inspect}" unless of.size == 1 && of.first
+
+    unwrap_of(of.first, dimensions + 1)
+  end
+
+  #--
+  #: (Module, Module?, Array[untyped]?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
+  def build_nested(type, of, enum, &block)
     raise Riffer::ArgumentError, "cannot use both of: and a block" if of && block
+    raise Riffer::ArgumentError, "enum: cannot be used with Hash" if enum && type == Hash
+    raise Riffer::ArgumentError, "enum: with Array requires of:" if enum && type == Array && !of
 
     if of
       raise Riffer::ArgumentError, "of: can only be used with Array type, got #{type}" unless type == Array
@@ -155,10 +184,26 @@ class Riffer::Params
     nested
   end
 
+  #--
+  #: ((Module | Array[untyped])?, Array[untyped]?) ?{ (Riffer::Params::AnyOf) [self: Riffer::Params::AnyOf] -> void } -> Array[Riffer::Params]
+  def build_variants(of, enum, &block)
+    raise Riffer::ArgumentError, "of: cannot be used with AnyOf" if of
+    raise Riffer::ArgumentError, "enum: cannot be used with AnyOf" if enum
+    raise Riffer::ArgumentError, "AnyOf requires a block defining its variants" unless block
+
+    any_of = Riffer::Params::AnyOf.new
+    any_of.instance_eval(&block)
+    raise Riffer::ArgumentError, "AnyOf requires at least two variants" if any_of.variants.size < 2
+
+    any_of.variants
+  end
+
   #--
   #: (Riffer::Params::Param, untyped, Array[String]) -> untyped
   def validate_nested(param, value, errors)
-    if param.type == Hash && param.nested_params
+    if param.type == Riffer::Params::AnyOf
+      validate_any_of(param, value, errors)
+    elsif param.type == Hash && param.nested_params
       validate_nested_hash(param, value, errors)
     elsif param.type == Array && param.nested_params
       validate_nested_array_of_objects(param, value, errors)
@@ -183,6 +228,49 @@ class Riffer::Params
     value
   end
 
+  #--
+  #: (Riffer::Params::Param, Hash[Symbol, untyped], Array[String]) -> Hash[Symbol, untyped]
+  def validate_any_of(param, value, errors)
+    variants = param.variants
+    return value unless variants
+
+    variant_errors = [] #: Array[String]
+    variants.each.with_index(1) do |variant, number|
+      validated = variant.validate(value)
+      # Each variant's schema sets additionalProperties: false on every object
+      # it declares, so a key outside this variant rules it out.
+      unknown = undeclared_keys(value, validated)
+      return validated if unknown.empty?
+
+      variant_errors << "variant #{number} (#{unknown.map { |path| "#{path} is not allowed" }.join(', ')})"
+    rescue Riffer::ValidationError => e
+      # Enclosing params split errors on "; " to prefix their path, so one
+      # variant's errors must not contain it.
+      variant_errors << "variant #{number} (#{e.message.gsub('; ', ', ')})"
+    end
+
+    errors << "#{param.name} must match one of the variants: #{variant_errors.join(', ')}"
+    value
+  end
+
+  # Validation drops keys a Params doesn't declare, at any depth, so they are
+  # the keys in the input that are missing from the output.
+  #--
+  #: (untyped, untyped, ?String?) -> Array[String]
+  def undeclared_keys(value, validated, path = nil)
+    case value
+    when Hash
+      value.flat_map do |key, child|
+        key_path = [path, key].compact.join(".")
+        validated.key?(key) ? undeclared_keys(child, validated[key], key_path) : [key_path]
+      end
+    when Array
+      value.each_with_index.flat_map { |item, i| undeclared_keys(item, validated[i], "#{path}[#{i}]") }
+    else
+      []
+    end
+  end
+
   #--
   #: (Riffer::Params::Param, Array[untyped], Array[String]) -> Array[untyped]
   def validate_nested_array_of_objects(param, value, errors)
@@ -204,22 +292,33 @@ class Riffer::Params
   end
 
   #--
-  #: (Riffer::Params::Param, Array[untyped], Array[String]) -> Array[untyped]
-  def validate_typed_array(param, value, errors)
+  #: (Riffer::Params::Param, Array[untyped], Array[String], ?String, ?Integer) -> Array[untyped]
+  def validate_typed_array(param, value, errors, path = param.name.to_s, dimensions = param.dimensions)
     item_type = param.item_type
     return value unless item_type
 
-    type_name = Riffer::Params::Param::TYPE_MAPPINGS[item_type]
-    valid_item = if [Riffer::Params::Boolean, TrueClass, FalseClass].include?(item_type)
-                   ->(item) { [true, false].include?(item) }
-                 elsif item_type == Float
-                   ->(item) { item.is_a?(Numeric) }
-                 else
-                   ->(item) { item.is_a?(item_type) }
-                 end
     value.map.with_index do |item, i|
-      unless valid_item.call(item)
-        errors << "#{param.name}[#{i}] must be a #{type_name}"
+      item_path = "#{path}[#{i}]"
+
+      if dimensions > 1
+        next validate_typed_array(param, item, errors, item_path, dimensions - 1) if item.is_a?(Array)
+
+        errors << "#{item_path} must be an array"
+        next item
+      end
+
+      unless valid_item?(item_type, item)
+        errors << "#{item_path} must be a #{Riffer::Params::Param::TYPE_MAPPINGS[item_type]}"
+        next item
+      end
+
+      if param.enum && !param.enum.include?(item)
+        errors << "#{item_path} must be one of: #{param.enum.join(', ')}"
+        next item
+      end
+
+      if param.format && !Riffer::Params::Format.valid?(param.format, item)
+        errors << "#{item_path} must be a valid #{param.format}"
         next item
       end
 
@@ -227,6 +326,18 @@ class Riffer::Params
     end
   end
 
+  #--
+  #: (Module, untyped) -> bool
+  def valid_item?(type, item)
+    if [Riffer::Params::Boolean, TrueClass, FalseClass].include?(type)
+      [true, false].include?(item)
+    elsif type == Float
+      item.is_a?(Numeric)
+    else
+      item.is_a?(type)
+    end
+  end
+
   #--
   #: (Module, untyped) -> untyped
   def coerce_value(type, value)

data/lib/riffer/providers/amazon_bedrock.rb

@@ -78,6 +78,20 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     end
   end
 
+  # Claude's fields, since application inference profile ARNs hide the model
+  # family; other families need a catalog entry.
+  #--
+  #: (Symbol) -> Hash[Symbol, untyped]
+  def default_reasoning_options(level)
+    fields =
+      if level == :off
+        { thinking: { type: "disabled" } }
+      else
+        { thinking: { type: "adaptive" }, output_config: { effort: level.to_s } }
+      end
+    { additional_model_request_fields: fields }
+  end
+
   #--
   #: (Array[Riffer::Messages::Base], String?, Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
   def build_request_params(messages, model, options)

data/lib/riffer/providers/anthropic.rb

@@ -56,6 +56,14 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     ::Anthropic::Client.new(**{ api_key: Riffer.config.anthropic.api_key }.compact)
   end
 
+  #--
+  #: (Symbol) -> Hash[Symbol, untyped]
+  def default_reasoning_options(level)
+    return { thinking: { type: "disabled" } } if level == :off
+
+    { thinking: { type: "adaptive" }, output_config: { effort: level.to_s } }
+  end
+
   #--
   #: (Array[Riffer::Messages::Base], String?, Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
   def build_request_params(messages, model, options)