riffer 0.47.2 → 0.49.0

data/lib/riffer/agent/session.rb

@@ -1,23 +1,11 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Owns the conversation handle for an agent: the message array, the
-# +on_message+ callbacks, and the +tool_use+ ↔ +tool_result+ invariant that
-# keeps tool calls and their results consistent.
-#
-#   agent.session.add(msg)                  # append + fire callbacks
-#   agent.session.set([msg1, msg2])         # bulk replace (silent)
-#   agent.session.unset                     # clear (silent)
-#   agent.session.remove(id: "a_1")
-#   agent.session.update(id: "a_1", content: "...")
-#   agent.session.find { |m| m.id == "a_1" }
-#
 class Riffer::Agent::Session
   include Enumerable #[Riffer::Messages::Base]
 
   # @rbs @callbacks: Array[^(Riffer::Messages::Base) -> void]
 
-  # The message history.
   attr_reader :messages #: Array[Riffer::Messages::Base] # @dynamic messages
 
   #--
@@ -27,7 +15,6 @@ class Riffer::Agent::Session
     @callbacks = [] #: Array[^(Riffer::Messages::Base) -> void]
   end
 
-  # Registers a callback invoked once per message appended via +#add+.
   #--
   #: () { (Riffer::Messages::Base) -> void } -> self
   def on_message(&block)
@@ -37,18 +24,15 @@ class Riffer::Agent::Session
     self
   end
 
-  # Appends +message+ and fires every registered callback once with it. Pass
-  # +silent: true+ to skip callbacks — used for non-inference inputs like user
-  # messages that subscribers don't expect on the callback channel.
   #--
   #: (Riffer::Messages::Base, ?silent: bool) -> Riffer::Messages::Base
   def add(message, silent: false)
-    @messages << message
+    @messages.insert(insertion_index(message), message)
+    # +silent+ is for non-inference inputs (e.g. user messages) that subscribers don't expect.
     @callbacks.each { |callback| callback.call(message) } unless silent
     message
   end
 
-  # Replaces the message history wholesale
   #--
   #: (Array[Riffer::Messages::Base]) -> self
   def set(messages)
@@ -56,7 +40,6 @@ class Riffer::Agent::Session
     self
   end
 
-  # Clears the session.
   #--
   #: () -> self
   def unset
@@ -64,10 +47,6 @@ class Riffer::Agent::Session
     self
   end
 
-  # Removes a message by id, cascading to drop the +Tool+ results of a removed
-  # assistant's +tool_calls+ so the +tool_use+ ↔ +tool_result+ invariant holds.
-  # Raises on a +Tool+ message — that would orphan its parent; use +#update+
-  # instead. Returns +nil+ if no message matches.
   #--
   #: (id: String) -> Riffer::Messages::Base?
   def remove(id:)
@@ -90,10 +69,6 @@ class Riffer::Agent::Session
     target
   end
 
-  # Partial in-place update: looks up a message by +id:+ or +tool_call_id:+
-  # (exactly one), overlays +attrs+ onto a same-type replacement, and swaps it
-  # in. Dropping +tool_calls+ from an assistant cascades to remove their +Tool+
-  # results, preserving the invariant. Raises on neither/both keys or no match.
   #--
   #: (?id: String?, ?tool_call_id: String?, **untyped) -> Riffer::Messages::Base
   def update(id: nil, tool_call_id: nil, **attrs)
@@ -118,9 +93,6 @@ class Riffer::Agent::Session
     replacement
   end
 
-  # Returns the call_ids of every +tool_call+ with no matching
-  # +Riffer::Messages::Tool+ result anywhere in history — a hook for checking
-  # the +tool_use+ ↔ +tool_result+ invariant before mutating or persisting.
   #--
   #: () -> Array[String]
   def orphaned_tool_call_ids
@@ -132,8 +104,6 @@ class Riffer::Agent::Session
     end
   end
 
-  # Returns +[last_assistant, pending_tool_calls]+; the second element is empty
-  # when there's no assistant message or no pending calls.
   #--
   #: () -> [Riffer::Messages::Assistant?, Array[Riffer::Messages::Assistant::ToolCall]]
   def pending_tool_calls
@@ -150,7 +120,14 @@ class Riffer::Agent::Session
     [assistant, assistant.tool_calls.reject { |tc| executed_ids.include?(tc.call_id) }]
   end
 
-  # Yields each message in order, or returns an Enumerator without a block.
+  #--
+  #: () -> Array[String]
+  def discard_pending_tool_calls
+    messages, filled = Repair.fill_orphans(@messages)
+    set(messages)
+    filled
+  end
+
   #--
   #: () -> Enumerator[Riffer::Messages::Base, self]
   #: () { (Riffer::Messages::Base) -> void } -> untyped
@@ -160,17 +137,12 @@ class Riffer::Agent::Session
     @messages.each(&block)
   end
 
-  # The number of LLM steps completed, used by the agent loop to enforce
-  # +max_steps+ on resume.
   #--
   #: () -> Integer
   def steps
     @messages.count { |m| m.is_a?(Riffer::Messages::Assistant) }
   end
 
-  # The most recent +Riffer::Messages::Assistant+ in the session, or +nil+
-  # when none exists.
-  #
   #--
   #: () -> Riffer::Messages::Assistant?
   def final_assistant_message
@@ -180,6 +152,21 @@ class Riffer::Agent::Session
 
   private
 
+  # Providers require tool results to directly follow their tool_use, but a
+  # resumed turn appends the new user message before pending calls execute.
+  #--
+  #: (Riffer::Messages::Base) -> Integer
+  def insertion_index(message)
+    return @messages.length unless message.is_a?(Riffer::Messages::Tool)
+
+    parent_idx = @messages.rindex do |m|
+      m.is_a?(Riffer::Messages::Assistant) && m.tool_calls.any? { |tc| tc.call_id == message.tool_call_id }
+    end
+    return @messages.length unless parent_idx
+
+    parent_idx + 1 + @messages.drop(parent_idx + 1).take_while { |m| m.is_a?(Riffer::Messages::Tool) }.length
+  end
+
   #--
   #: (Riffer::Messages::Base, Riffer::Messages::Base) -> void
   def cascade_dropped_tool_calls(old, replacement)
@@ -201,6 +188,7 @@ class Riffer::Agent::Session
         attrs.fetch(:content, old.content),
         id: attrs.fetch(:id, old.id),
         tool_calls: attrs.fetch(:tool_calls, old.tool_calls),
+        reasoning: attrs.fetch(:reasoning, old.reasoning),
         token_usage: attrs.fetch(:token_usage, old.token_usage),
         structured_output: attrs.fetch(:structured_output, old.structured_output),
         finish_reason: attrs.fetch(:finish_reason, old.finish_reason),

data/lib/riffer/agent/structured_output/result.rb

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 # rbs_inline: enabled
 
-# Wraps the result of structured output parsing and validation.
 class Riffer::Agent::StructuredOutput::Result
-  # The validated object, or +nil+ on failure.
   attr_reader :object #: Hash[Symbol, untyped]? # @dynamic object
-
-  # The error message, or +nil+ on success.
   attr_reader :error #: String? # @dynamic error
 
   #--
@@ -16,14 +12,10 @@ class Riffer::Agent::StructuredOutput::Result
     @error = error
   end
 
-  # Returns true when parsing and validation succeeded.
-  #
   #--
   #: () -> bool
   def success? = @error.nil?
 
-  # Returns true when parsing or validation failed.
-  #
   #--
   #: () -> bool
   def failure? = !success?

data/lib/riffer/agent/structured_output.rb

@@ -3,10 +3,7 @@
 
 require "json"
 
-# Parses and validates structured JSON responses against a Riffer::Params
-# schema.
 class Riffer::Agent::StructuredOutput
-  # The schema parameters.
   attr_reader :params #: Riffer::Params # @dynamic params
 
   #--
@@ -15,16 +12,12 @@ class Riffer::Agent::StructuredOutput
     @params = params
   end
 
-  # Returns the JSON Schema for this structured output.
-  #
   #--
   #: (?strict: bool) -> Hash[Symbol, untyped]
   def json_schema(strict: false)
     @params.to_json_schema(strict: strict)
   end
 
-  # Parses a JSON string and validates it against the schema, returning a
-  # Result carrying either the validated object or an error message.
   #--
   #: (String) -> Riffer::Agent::StructuredOutput::Result
   def parse_and_validate(json_string)

data/lib/riffer/agent.rb

@@ -3,17 +3,6 @@
 
 require "json"
 
-# Base class for all agents in the Riffer framework. Subclass it to define an
-# agent's model, instructions, tools, and guardrails.
-#
-#   class MyAgent < Riffer::Agent
-#     model 'openai/gpt-4o'
-#     instructions 'You are a helpful assistant.'
-#   end
-#
-#   agent = MyAgent.new
-#   agent.generate('Hello!')
-#
 class Riffer::Agent
   extend Riffer::Registrable
 
@@ -21,53 +10,48 @@ class Riffer::Agent
 
   INTERRUPT_MAX_STEPS = :max_steps #: Symbol
 
-  # Returns the per-class Riffer::Agent::Config holding every DSL setting.
   #--
   #: () -> Riffer::Agent::Config
   def self.config
     @config ||= Riffer::Agent::Config.new
   end
 
-  # Gets or sets the agent identifier.
-  #
+  #--
+  #: (Class) -> void
+  def self.inherited(subclass)
+    super
+    copy = config.dup
+    # The identifier is identity, not inheritable config: two classes claiming
+    # one raise Riffer::DuplicateIdentifierError at the next registry lookup.
+    copy.identifier = nil
+    subclass.instance_variable_set(:@config, copy)
+  end
+  private_class_method :inherited
+
   #--
   #: (?String?) -> String
   def self.identifier(value = nil)
     value.nil? ? (config.identifier || Riffer::Helpers::Identifier.for(self)) : (config.identifier = value)
   end
 
-  # Gets or sets the model string (e.g., "openai/gpt-4o").
-  #
   #--
   #: (?(String | Proc)?) -> (String | Proc)?
   def self.model(value = nil)
     value.nil? ? config.model : (config.model = value)
   end
 
-  # Gets or sets the agent instructions. A Proc is called at generate time with
-  # the +context+ hash (which may be +nil+).
-  #
-  #   instructions "You are a helpful assistant."
-  #
-  #   instructions -> (context) {
-  #     "You are assisting #{context[:name]}"
-  #   }
-  #
   #--
   #: (?(String | Proc)?) -> (String | Proc)?
   def self.instructions(value = nil)
     value.nil? ? config.instructions : (config.instructions = value)
   end
 
-  # Gets or sets model options passed to generate_text/stream_text.
-  #
   #--
   #: (?Hash[Symbol, untyped]?) -> Hash[Symbol, untyped]
   def self.model_options(options = nil)
     options.nil? ? config.model_options : (config.model_options = options)
   end
 
-  # Gets or sets the structured output schema for this agent.
   #--
   #: (?Riffer::Params?) ?{ (Riffer::Params) [self: Riffer::Params] -> void } -> Riffer::Params?
   def self.structured_output(params = nil, &block)
@@ -79,62 +63,39 @@ class Riffer::Agent
     config.structured_output
   end
 
-  # Gets or sets the maximum number of LLM call steps in the tool-use loop.
-  # The splat distinguishes a getter (no argument) from setting the limit to
-  # +nil+ (unlimited); it defaults to Riffer::Agent::Config::DEFAULT_MAX_STEPS.
-  #
-  #   max_steps        # reads the current limit
-  #   max_steps 8      # cap the loop at 8 steps
-  #   max_steps nil    # unlimited
-  #
   #--
   #: (*Numeric?) -> Numeric?
   def self.max_steps(*value)
+    # The splat tells a bare read apart from +max_steps nil+ (unlimited).
     return config.max_steps if value.empty?
 
     config.max_steps = value.first
   end
 
-  # Gets or sets the tools used by this agent.
-  #
   #--
   #: (?(Array[singleton(Riffer::Tool)] | Proc)?) -> (Array[singleton(Riffer::Tool)] | Proc)?
   def self.uses_tools(value = nil)
     value.nil? ? config.tools_config : (config.tools_config = value)
   end
 
-  # Opts this agent into MCP tools from registrations matching the given tag.
-  # Progressive registrations expose +mcp_search+ instead of every schema up front.
-  #
+  # +progressive+ exposes +mcp_search+ instead of every tool schema up front.
+  #--
   #: (String | Symbol, ?progressive: bool) -> void
   def self.use_mcp(tag, progressive: true)
     config.add_mcp(tag, progressive: progressive)
   end
 
-  # Returns the accumulated +use_mcp+ configurations for this agent class.
-  #
   #: () -> Array[Hash[Symbol, untyped]]
   def self.mcp_configs
     config.mcp_configs
   end
 
-  # Gets or sets the tool runtime for this agent; defaults to
-  # <tt>Riffer.config.tool_runtime</tt> when unset.
   #--
   #: (?(singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)
   def self.tool_runtime(value = nil)
     value.nil? ? config.tool_runtime : (config.tool_runtime = value)
   end
 
-  # Configures skills for this agent via a block DSL, or returns the current
-  # Riffer::Skills::Config when called without a block.
-  #
-  #   skills do
-  #     backend Riffer::Skills::FilesystemBackend.new(".skills")
-  #     adapter Riffer::Skills::XmlAdapter
-  #     activate ["code-review"]
-  #   end
-  #
   #--
   #: () ?{ (Riffer::Skills::Config) [self: Riffer::Skills::Config] -> void } -> Riffer::Skills::Config?
   def self.skills(&block)
@@ -146,21 +107,18 @@ class Riffer::Agent
     config.skills_config
   end
 
-  # Generates a response using a new agent instance.
   #--
-  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?context: Hash[Symbol, untyped]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response
+  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::User::FilePart]?, ?context: Hash[Symbol, untyped]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response
   def self.generate(prompt = nil, files: nil, context: nil, tags: {})
     new(context: context).generate(prompt, files: files, tags: tags)
   end
 
-  # Streams a response using a new agent instance.
   #--
-  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?context: Hash[Symbol, untyped]?, ?tags: Hash[(String | Symbol), untyped]) -> Enumerator[Riffer::StreamEvents::Base, Riffer::Agent::Response]
+  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::User::FilePart]?, ?context: Hash[Symbol, untyped]?, ?tags: Hash[(String | Symbol), untyped]) -> Enumerator[Riffer::StreamEvents::Base, Riffer::Agent::Response]
   def self.stream(prompt = nil, files: nil, context: nil, tags: {})
     new(context: context).stream(prompt, files: files, tags: tags)
   end
 
-  # Reconstructs a runnable agent from a wire hash produced by +#to_h+.
   #--
   #: (Hash[Symbol, untyped], ?context: Hash[Symbol, untyped]?, ?session: Riffer::Agent::Session?, ?tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), ?tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent
   def self.from_h(
@@ -179,7 +137,6 @@ class Riffer::Agent
     )
   end
 
-  # Reconstructs a runnable agent from a JSON string produced by +#to_json+.
   #--
   #: (String, ?context: Hash[Symbol, untyped]?, ?session: Riffer::Agent::Session?, ?tool_resolver: ^(Hash[Symbol, untyped]) -> singleton(Riffer::Tool), ?tool_runtime: (singleton(Riffer::Tools::Runtime) | Riffer::Tools::Runtime | Proc)?) -> Riffer::Agent
   def self.from_json(
@@ -198,70 +155,33 @@ class Riffer::Agent
     )
   end
 
-  # Registers a guardrail for input, output, or both phases. Raises
-  # Riffer::ArgumentError unless +phase+ is :before, :after, or :around.
   #--
   #: (Symbol, with: singleton(Riffer::Guardrail), **untyped) -> void
   def self.guardrail(phase, with:, **options)
     config.add_guardrail(phase, klass: with, options: options)
   end
 
-  # Returns the registered guardrail configs for a given phase.
   #--
   #: (Symbol) -> Array[Hash[Symbol, untyped]]
   def self.guardrails_for(phase)
     config.guardrails_for(phase)
   end
 
-  # The conversation handle.
   attr_reader :session #: Riffer::Agent::Session # @dynamic session
-
-  # The per-instance Riffer::Agent::Config.
   attr_reader :config #: Riffer::Agent::Config # @dynamic config
-
-  # The system message built from the configured +instructions+, or +nil+ when
-  # none are configured.
   attr_reader :instruction_message #: Riffer::Messages::System? # @dynamic instruction_message
-
-  # The system message describing the configured skills catalog, or +nil+ when
-  # skills are unconfigured or the catalog is empty.
   attr_reader :skills_message #: Riffer::Messages::System? # @dynamic skills_message
-
-  # The mutable runtime context shared with every +Riffer::Agent::Run+ this
-  # agent executes and threaded through all Proc-based settings.
   attr_reader :context #: Riffer::Agent::Context # @dynamic context
-
-  # The resolved provider name (the part before "/" in the model string),
-  # e.g. +"openai"+.
   attr_reader :provider_name #: String # @dynamic provider_name
-
-  # The resolved model name (the part after "/" in the model string), used as
-  # the model argument on every LLM call.
   attr_reader :model_name #: String # @dynamic model_name
 
-  # The provider client. Public so tests can pre-queue responses on
-  # +Riffer::Providers::Mock+ before calling +#generate+.
+  # Public so tests can pre-queue responses on Riffer::Providers::Mock.
   attr_reader :provider #: Riffer::Providers::Base # @dynamic provider
 
-  # The +Riffer::Agent::StructuredOutput+ wrapping the configured schema, or
-  # +nil+ when not configured.
   attr_reader :structured_output #: Riffer::Agent::StructuredOutput? # @dynamic structured_output
-
-  # The tool classes the LLM sees on every call this agent makes.
   attr_reader :tools #: Array[singleton(Riffer::Tool)] # @dynamic tools
-
-  # The tool runtime instance used to execute tool calls.
   attr_reader :tool_runtime #: Riffer::Tools::Runtime # @dynamic tool_runtime
 
-  # Initializes a new agent.
-  #
-  # A provided +session:+ is used as-is — the caller owns its contents (e.g.
-  # cross-process resume from persisted history); an omitted one is seeded with
-  # the instruction and skills messages.
-  #
-  # Raises Riffer::ArgumentError unless the configured model string is
-  # "provider/model" format.
-  #
   #--
   #: (?session: Riffer::Agent::Session?, ?context: Hash[Symbol, untyped]?, ?config: Riffer::Agent::Config?) -> void
   def initialize(session: nil, context: nil, config: nil)
@@ -280,38 +200,26 @@ class Riffer::Agent
     @instruction_message = build_instruction_message
     @skills_message = build_skills_message
 
+    # A caller-supplied session owns its contents (e.g. resumed history), so it
+    # is not seeded.
     @session = session || Riffer::Agent::Session.new(messages: [@instruction_message, @skills_message].compact)
     @session.set(Riffer::Agent::Session::Repair.prune_orphans(@session.messages))
   end
 
-  # Generates a response from the agent.
-  #
-  # With +prompt+, a new user message is appended (silently — +on_message+ does
-  # not fire for user inputs) before the loop runs. Without it, the loop runs
-  # against the current session, resuming a persisted conversation or pending
-  # tool calls. +files:+ requires +prompt+.
-  #
-  # +tags:+ is an optional flat hash of attribution tags applied to this single
-  # call: they propagate to the provider's native request-metadata field, and
-  # are stamped as +riffer.tag.*+ on every span the call emits. See
-  # +docs/AGENTS.md+ for the per-provider mapping. The reserved key
-  # +user_id+ also maps to the provider's native user identifier where one
-  # exists.
-  #
-  #--
-  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response
+  #--
+  #: () -> String
+  def identifier
+    config.identifier || self.class.identifier
+  end
+
+  #--
+  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::User::FilePart]?, ?tags: Hash[(String | Symbol), untyped]) -> Riffer::Agent::Response
   def generate(prompt = nil, files: nil, tags: {})
     Riffer::Agent::Run.generate(agent: self, prompt: prompt, files: files, tags: tags)
   end
 
-  # Streams a response from the agent as an +Enumerator+ of
-  # +Riffer::StreamEvents+ whose block-form +each+ returns the final
-  # Riffer::Agent::Response. See +#generate+ for prompt/files/tags semantics.
-  #
-  # Raises Riffer::ArgumentError if structured output is configured.
-  #
   #--
-  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::FilePart]?, ?tags: Hash[(String | Symbol), untyped]) -> Enumerator[Riffer::StreamEvents::Base, Riffer::Agent::Response]
+  #: (?String?, ?files: Array[Hash[Symbol, untyped] | Riffer::Messages::User::FilePart]?, ?tags: Hash[(String | Symbol), untyped]) -> Enumerator[Riffer::StreamEvents::Base, Riffer::Agent::Response]
   def stream(prompt = nil, files: nil, tags: {})
     if @structured_output
       raise Riffer::ArgumentError,
@@ -321,24 +229,20 @@ class Riffer::Agent
     Riffer::Agent::Run.stream(agent: self, prompt: prompt, files: files, tags: tags)
   end
 
-  # Interrupts the agent loop from an +on_message+ callback. Equivalent to
-  # <tt>throw :riffer_interrupt, reason</tt>.
   #--
   #: (?(String | Symbol)?) -> void
   def interrupt!(reason = nil)
     throw :riffer_interrupt, reason
   end
 
-  # Snapshots this resolved agent into a self-contained, provider-neutral wire
-  # hash.
   #--
   #: () -> Hash[Symbol, untyped]
   def to_h
     Riffer::Agent::Serializer.to_h(agent: self)
   end
 
-  # Snapshots this resolved agent into a wire JSON string. The +*+ absorbs the
-  # JSON generator state argument so <tt>JSON.generate(agent)</tt> works too.
+  # The +*+ absorbs JSON's generator-state argument so
+  # <tt>JSON.generate(agent)</tt> works.
   #--
   #: (*untyped) -> String
   def to_json(*)

data/lib/riffer/config/amazon_bedrock.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::AmazonBedrock
+  attr_reader :api_token #: String? # @dynamic api_token
+
+  attr_reader :region #: String? # @dynamic region
+
+  attr_accessor :client #: untyped # @dynamic client, client=
+
+  #--
+  #: () -> void
+  def initialize
+    @api_token = nil
+    @region = nil
+    @client = nil
+  end
+
+  #--
+  #: (untyped) -> void
+  def api_token=(value)
+    @api_token = Riffer::Helpers::Validate.optional_string(value, attribute: "api_token")
+  end
+
+  #--
+  #: (untyped) -> void
+  def region=(value)
+    @region = Riffer::Helpers::Validate.optional_string(value, attribute: "region")
+  end
+end

data/lib/riffer/config/anthropic.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Anthropic
+  attr_reader :api_key #: String? # @dynamic api_key
+
+  attr_accessor :client #: untyped # @dynamic client, client=
+
+  #--
+  #: () -> void
+  def initialize
+    @api_key = nil
+    @client = nil
+  end
+
+  #--
+  #: (untyped) -> void
+  def api_key=(value)
+    @api_key = Riffer::Helpers::Validate.optional_string(value, attribute: "api_key")
+  end
+end

data/lib/riffer/config/azure_open_ai.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::AzureOpenAI
+  attr_reader :api_key #: String? # @dynamic api_key
+
+  attr_reader :endpoint #: String? # @dynamic endpoint
+
+  attr_accessor :client #: untyped # @dynamic client, client=
+
+  #--
+  #: () -> void
+  def initialize
+    @api_key = nil
+    @endpoint = nil
+    @client = nil
+  end
+
+  #--
+  #: (untyped) -> void
+  def api_key=(value)
+    @api_key = Riffer::Helpers::Validate.optional_string(value, attribute: "api_key")
+  end
+
+  #--
+  #: (untyped) -> void
+  def endpoint=(value)
+    @endpoint = Riffer::Helpers::Validate.optional_string(value, attribute: "endpoint")
+  end
+end

data/lib/riffer/config/evals.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Evals
+  attr_reader :judge_model #: String? # @dynamic judge_model
+
+  #--
+  #: () -> void
+  def initialize
+    @judge_model = nil
+  end
+
+  #--
+  #: (untyped) -> void
+  def judge_model=(value)
+    @judge_model = value.nil? ? nil : Riffer::Helpers::Validate.model_id(value, attribute: "judge_model")
+  end
+end