dify_llm 1.6.4

data/lib/ruby_llm/model/modalities.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # Holds and manages input and output modalities for a language model
+    class Modalities
+      attr_reader :input, :output
+
+      def initialize(data)
+        @input = Array(data[:input]).map(&:to_s)
+        @output = Array(data[:output]).map(&:to_s)
+      end
+
+      def to_h
+        {
+          input: input,
+          output: output
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/model/pricing.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # A collection that manages and provides access to different categories of pricing information
+    class Pricing
+      def initialize(data)
+        @data = {}
+
+        %i[text_tokens images audio_tokens embeddings].each do |category|
+          @data[category] = PricingCategory.new(data[category]) if data[category] && !empty_pricing?(data[category])
+        end
+      end
+
+      def method_missing(method, *args)
+        if respond_to_missing?(method)
+          @data[method.to_sym] || PricingCategory.new
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        %i[text_tokens images audio_tokens embeddings].include?(method.to_sym) || super
+      end
+
+      def to_h
+        @data.transform_values(&:to_h)
+      end
+
+      private
+
+      def empty_pricing?(data)
+        return true unless data
+
+        %i[standard batch].each do |tier|
+          next unless data[tier]
+
+          data[tier].each_value do |value|
+            return false if value && value != 0.0
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/ruby_llm/model/pricing_category.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # Represents pricing tiers for different usage categories (standard and batch)
+    class PricingCategory
+      attr_reader :standard, :batch
+
+      def initialize(data = {})
+        @standard = PricingTier.new(data[:standard] || {}) unless empty_tier?(data[:standard])
+        @batch = PricingTier.new(data[:batch] || {}) unless empty_tier?(data[:batch])
+      end
+
+      def input
+        standard&.input_per_million
+      end
+
+      def output
+        standard&.output_per_million
+      end
+
+      def cached_input
+        standard&.cached_input_per_million
+      end
+
+      def [](key)
+        key == :batch ? batch : standard
+      end
+
+      def to_h
+        result = {}
+        result[:standard] = standard.to_h if standard
+        result[:batch] = batch.to_h if batch
+        result
+      end
+
+      private
+
+      def empty_tier?(tier_data)
+        return true unless tier_data
+
+        tier_data.values.all? { |v| v.nil? || v == 0.0 }
+      end
+    end
+  end
+end

data/lib/ruby_llm/model/pricing_tier.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # A dynamic class for storing non-zero pricing values with flexible attribute access
+    class PricingTier
+      def initialize(data = {})
+        @values = {}
+
+        data.each do |key, value|
+          @values[key.to_sym] = value if value && value != 0.0
+        end
+      end
+
+      def method_missing(method, *args)
+        if method.to_s.end_with?('=')
+          key = method.to_s.chomp('=').to_sym
+          @values[key] = args.first if args.first && args.first != 0.0
+        elsif @values.key?(method)
+          @values[method]
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        method.to_s.end_with?('=') || @values.key?(method.to_sym) || super
+      end
+
+      def to_h
+        @values
+      end
+    end
+  end
+end

data/lib/ruby_llm/model.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Model-related classes for working with LLM models
+  module Model
+  end
+end