riffer 0.47.2 → 0.49.0

data/lib/riffer/config/files.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Files
+  attr_reader :allow_downloads #: bool # @dynamic allow_downloads
+  attr_reader :max_bytes #: Integer # @dynamic max_bytes
+  attr_reader :timeout #: Integer # @dynamic timeout
+  attr_reader :max_per_message #: Integer? # @dynamic max_per_message
+  attr_reader :runner #: Riffer::Runner # @dynamic runner
+  attr_reader :downloader #: untyped # @dynamic downloader
+
+  #--
+  #: () -> void
+  def initialize
+    @allow_downloads = false
+    @max_bytes = 3_500_000
+    @timeout = 60
+    @max_per_message = nil
+    @runner = Riffer::Runner::Sequential.new
+    @downloader = Riffer::Files::Downloader.new
+  end
+
+  #--
+  #: (untyped) -> void
+  def allow_downloads=(value)
+    @allow_downloads = Riffer::Helpers::Boolean.coerce(value, attribute: "allow_downloads")
+  end
+
+  #--
+  #: (untyped) -> void
+  def max_bytes=(value)
+    @max_bytes = Riffer::Helpers::Validate.positive_integer(value, attribute: "max_bytes")
+  end
+
+  #--
+  #: (untyped) -> void
+  def timeout=(value)
+    @timeout = Riffer::Helpers::Validate.positive_integer(value, attribute: "timeout")
+  end
+
+  #--
+  #: (untyped) -> void
+  def max_per_message=(value)
+    @max_per_message =
+      value.nil? ? nil : Riffer::Helpers::Validate.positive_integer(value, attribute: "max_per_message")
+  end
+
+  #--
+  #: (untyped) -> void
+  def runner=(value)
+    @runner = Riffer::Helpers::Validate.runner(value, attribute: "runner")
+  end
+
+  #--
+  #: (untyped) -> void
+  def downloader=(value)
+    raise Riffer::ArgumentError, "downloader must respond to #call" unless value.respond_to?(:call)
+
+    @downloader = value
+  end
+end

data/lib/riffer/config/gemini.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Gemini
+  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/mcp.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Mcp
+  attr_reader :credentials #: untyped # @dynamic credentials
+
+  attr_reader :discovery_runner #: Riffer::Runner # @dynamic discovery_runner
+
+  #--
+  #: () -> void
+  def initialize
+    @credentials = nil
+    @discovery_runner = Riffer::Runner::Sequential.new
+  end
+
+  #--
+  #: (untyped) -> void
+  def credentials=(value)
+    unless value.nil? || value.respond_to?(:call)
+      raise Riffer::ArgumentError, "credentials must respond to #call or be nil"
+    end
+
+    @credentials = value
+  end
+
+  #--
+  #: (untyped) -> void
+  def discovery_runner=(value)
+    @discovery_runner = Riffer::Helpers::Validate.runner(value, attribute: "discovery_runner")
+  end
+end

data/lib/riffer/config/open_ai.rb

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

data/lib/riffer/config/open_router.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::OpenRouter
+  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/pricing/rates.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Pricing::Rates
+  attr_reader :input #: Float # @dynamic input
+
+  attr_reader :output #: Float # @dynamic output
+
+  attr_reader :cache_read #: Float? # @dynamic cache_read
+
+  attr_reader :cache_write #: Float? # @dynamic cache_write
+
+  #--
+  #: (input: Float, output: Float, ?cache_read: Float?, ?cache_write: Float?) -> void
+  def initialize(input:, output:, cache_read: nil, cache_write: nil)
+    @input = input
+    @output = output
+    @cache_read = cache_read
+    @cache_write = cache_write
+  end
+
+  #--
+  #: (input_tokens: Integer, output_tokens: Integer, ?cache_read_tokens: Integer?, ?cache_write_tokens: Integer?) -> Float
+  def cost_for(input_tokens:, output_tokens:, cache_read_tokens: nil, cache_write_tokens: nil)
+    read = cache_read_tokens || 0
+    write = cache_write_tokens || 0
+    uncached = input_tokens - read - write
+    uncached = 0 if uncached.negative?
+
+    per_million = (uncached * input) +
+                  (read * (cache_read || input)) +
+                  (write * (cache_write || input)) +
+                  (output_tokens * output)
+    per_million / 1_000_000.0
+  end
+end

data/lib/riffer/config/pricing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Pricing
+  # @rbs @rates: Hash[String, Riffer::Config::Pricing::Rates]
+
+  #--
+  #: () -> void
+  def initialize
+    @rates = {}
+  end
+
+  #--
+  #: ((String | Array[String]), input: Numeric, output: Numeric, ?cache_read: Numeric?, ?cache_write: Numeric?) -> void
+  def set(models, input:, output:, cache_read: nil, cache_write: nil)
+    ids = models.is_a?(Array) ? models : [models]
+    raise Riffer::ArgumentError, "at least one model id is required" if ids.empty?
+
+    ids.each { |id| Riffer::Helpers::Validate.model_id(id, attribute: "pricing model id") }
+
+    rates = Rates.new(
+      input: coerce_rate(input, "input"),
+      output: coerce_rate(output, "output"),
+      cache_read: coerce_optional_rate(cache_read, "cache_read"),
+      cache_write: coerce_optional_rate(cache_write, "cache_write"),
+    )
+    ids.each { |id| @rates[id] = rates }
+  end
+
+  #--
+  #: (String) -> Riffer::Config::Pricing::Rates?
+  def rates_for(model)
+    @rates[model]
+  end
+
+  #--
+  #: () -> bool
+  def empty?
+    @rates.empty?
+  end
+
+  private
+
+  #--
+  #: (untyped, String) -> Float
+  def coerce_rate(value, attribute)
+    number = value
+    float = value.is_a?(Numeric) ? number.to_f : nil #: Float?
+    unless float&.finite? && float >= 0
+      raise Riffer::ArgumentError,
+            "#{attribute} rate must be a non-negative number, got #{value.inspect}"
+    end
+
+    float
+  end
+
+  #--
+  #: (untyped, String) -> Float?
+  def coerce_optional_rate(value, attribute)
+    return nil if value.nil?
+
+    coerce_rate(value, attribute)
+  end
+end

data/lib/riffer/config/skills.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Skills
+  attr_reader :default_activate_tool #: singleton(Riffer::Tool) # @dynamic default_activate_tool
+
+  attr_reader :default_backend #: (Riffer::Skills::Backend | Proc)? # @dynamic default_backend
+
+  #--
+  #: () -> void
+  def initialize
+    @default_activate_tool = Riffer::Skills::ActivateTool
+    @default_backend = nil
+  end
+
+  #--
+  #: (singleton(Riffer::Tool)) -> void
+  def default_activate_tool=(value)
+    unless value.is_a?(Class) && value < Riffer::Tool
+      raise Riffer::ArgumentError,
+            "default_activate_tool must be a Riffer::Tool subclass"
+    end
+
+    @default_activate_tool = value
+  end
+
+  #--
+  #: ((Riffer::Skills::Backend | Proc)?) -> void
+  def default_backend=(value)
+    valid = value.nil? || value.is_a?(Riffer::Skills::Backend) || value.is_a?(Proc)
+    unless valid
+      raise Riffer::ArgumentError,
+            "default_backend must be a Riffer::Skills::Backend instance, Proc, or nil"
+    end
+
+    @default_backend = value
+  end
+end

data/lib/riffer/config/tracing.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+class Riffer::Config::Tracing
+  attr_reader :enabled #: bool # @dynamic enabled
+
+  attr_reader :capture_messages #: bool # @dynamic capture_messages
+
+  attr_reader :backend #: untyped # @dynamic backend
+
+  #--
+  #: () -> void
+  def initialize
+    # Spans are a no-op until a host wires an OTEL SDK.
+    @enabled = true
+    # Message content routinely carries sensitive data.
+    @capture_messages = false
+    @backend = nil
+  end
+
+  #--
+  #: (untyped) -> void
+  def enabled=(value)
+    @enabled = Riffer::Helpers::Boolean.coerce(value, attribute: "enabled")
+  end
+
+  #--
+  #: (untyped) -> void
+  def capture_messages=(value)
+    @capture_messages = Riffer::Helpers::Boolean.coerce(value, attribute: "capture_messages")
+  end
+
+  #--
+  #: (untyped) -> void
+  def backend=(value)
+    contract = %i[in_span current_context with_context]
+    unless value.nil? || contract.all? { |method| value.respond_to?(method) }
+      raise Riffer::ArgumentError, "tracing backend must respond to #in_span, #current_context, and #with_context"
+    end
+
+    @backend = value
+  end
+end