class Riffer::Params::Param

Riffer::Params::Param represents a single parameter definition.

Handles type validation and JSON Schema generation for individual parameters.

Constants

PRIMITIVE_TYPES: Primitive types allowed for the of: keyword on Array params
TYPE_MAPPINGS: Maps Ruby types to JSON Schema type strings

Attributes

default [R]

description [R]

enum [R]

item_type [R]

name [R]

nested_params [R]

required [R]

type [R]

Public Class Methods

new (name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil)

Source

# File lib/riffer/params/param.rb, line 34
def initialize(name:, type:, required:, description: nil, enum: nil, default: nil, item_type: nil, nested_params: nil)
  @name = name.to_sym
  @type = type
  @required = required
  @description = description
  @enum = enum
  @default = default
  @item_type = item_type
  @nested_params = nested_params
end

Public Instance Methods

to_json_schema (strict: false)

Source

# File lib/riffer/params/param.rb, line 79
def to_json_schema(strict: false)
  nullable = strict && !required

  if nullable && enum
    schema = {anyOf: [{type: type_name, enum: enum}, {type: "null"}]} #: Hash[Symbol, untyped]
    schema[:description] = description if description
    return schema
  end

  type = type_name
  type = [type, "null"] if nullable

  schema = {type: type} #: Hash[Symbol, untyped]
  schema[:description] = description if description
  schema[:enum] = enum if enum

  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]}
  elsif self.type == Hash && nested_params
    schema.merge!(nested_params.to_json_schema(strict: strict))
  end

  schema
end

Converts this parameter to JSON Schema format.

When strict is true, optional parameters are made nullable (["type", "null"]) so that strict mode providers can distinguish “absent” from “present” without rejecting the schema.

Optional parameters with an enum use anyOf to separate the enum constraint from the null type, since providers like Anthropic reject {"type": ["string", "null"], "enum": [...]}.

type_name ()

Source

# File lib/riffer/params/param.rb, line 63
def type_name
  TYPE_MAPPINGS[type] || type.to_s.downcase
end

Returns the JSON Schema type name for this parameter.

valid_type? (value)

Source

# File lib/riffer/params/param.rb, line 49
def valid_type?(value)
  return true if value.nil? && !required

  if type == Riffer::Params::Boolean || type == TrueClass || type == FalseClass
    value == true || value == false
  else
    value.is_a?(type)
  end
end

Validates that a value matches the expected type.