ruby_llm_community 1.1.1 → 1.3.0

data/lib/ruby_llm/models.rb

@@ -10,16 +10,19 @@ module RubyLLM
         @instance ||= new
       end
 
-      def provider_for(model)
-        Provider.for(model)
+      def schema_file
+        File.expand_path('models_schema.json', __dir__)
       end
 
-      def models_file
-        File.expand_path('models.json', __dir__)
+      def load_models(file = RubyLLM.config.model_registry_file)
+        read_from_json(file)
       end
 
-      def schema_file
-        File.expand_path('models_schema.json', __dir__)
+      def read_from_json(file = RubyLLM.config.model_registry_file)
+        data = File.exist?(file) ? File.read(file) : '[]'
+        JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
+      rescue JSON::ParserError
+        []
       end
 
       def refresh!(remote_only: false)
@@ -151,26 +154,15 @@ module RubyLLM
     end
 
     def initialize(models = nil)
-      @models = models || load_models
-    end
-
-    def load_models
-      read_from_json
-    end
-
-    def load_from_json!
-      @models = read_from_json
+      @models = models || self.class.load_models
     end
 
-    def read_from_json
-      data = File.exist?(self.class.models_file) ? File.read(self.class.models_file) : '[]'
-      JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
-    rescue JSON::ParserError
-      []
+    def load_from_json!(file = RubyLLM.config.model_registry_file)
+      @models = self.class.read_from_json(file)
     end
 
-    def save_to_json
-      File.write(self.class.models_file, JSON.pretty_generate(all.map(&:to_h)))
+    def save_to_json(file = RubyLLM.config.model_registry_file)
+      File.write(file, JSON.pretty_generate(all.map(&:to_h)))
     end
 
     def all
@@ -194,15 +186,15 @@ module RubyLLM
     end
 
     def embedding_models
-      self.class.new(all.select { |m| m.type == 'embedding' })
+      self.class.new(all.select { |m| m.type == 'embedding' || m.modalities.output.include?('embeddings') })
     end
 
     def audio_models
-      self.class.new(all.select { |m| m.type == 'audio' })
+      self.class.new(all.select { |m| m.type == 'audio' || m.modalities.output.include?('audio') })
     end
 
     def image_models
-      self.class.new(all.select { |m| m.type == 'image' })
+      self.class.new(all.select { |m| m.type == 'image' || m.modalities.output.include?('image') })
     end
 
     def by_family(family)
@@ -217,6 +209,10 @@ module RubyLLM
       self.class.refresh!(remote_only: remote_only)
     end
 
+    def resolve(model_id, provider: nil, assume_exists: false, config: nil)
+      self.class.resolve(model_id, provider: provider, assume_exists: assume_exists, config: config)
+    end
+
     private
 
     def find_with_provider(model_id, provider)

data/lib/ruby_llm/moderation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Identify potentially harmful content in text.
+  # https://platform.openai.com/docs/guides/moderation
+  class Moderation
+    attr_reader :id, :model, :results
+
+    def initialize(id:, model:, results:)
+      @id = id
+      @model = model
+      @results = results
+    end
+
+    def self.moderate(input,
+                      model: nil,
+                      provider: nil,
+                      assume_model_exists: false,
+                      context: nil)
+      config = context&.config || RubyLLM.config
+      model ||= config.default_moderation_model || 'omni-moderation-latest'
+      model, provider_instance = Models.resolve(model, provider: provider, assume_exists: assume_model_exists,
+                                                       config: config)
+      model_id = model.id
+
+      provider_instance.moderate(input, model: model_id)
+    end
+
+    # Convenience method to get content from moderation result
+    def content
+      results
+    end
+
+    # Check if any content was flagged
+    def flagged?
+      results.any? { |result| result['flagged'] }
+    end
+
+    # Get all flagged categories across all results
+    def flagged_categories
+      results.flat_map do |result|
+        result['categories']&.select { |_category, flagged| flagged }&.keys || []
+      end.uniq
+    end
+
+    # Get category scores for the first result (most common case)
+    def category_scores
+      results.first&.dig('category_scores') || {}
+    end
+
+    # Get categories for the first result (most common case)
+    def categories
+      results.first&.dig('categories') || {}
+    end
+  end
+end

data/lib/ruby_llm/provider.rb

@@ -74,12 +74,25 @@ module RubyLLM
       parse_embedding_response(response, model:, text:)
     end
 
+    def moderate(input, model:)
+      payload = render_moderation_payload(input, model:)
+      response = @connection.post moderation_url, payload
+      parse_moderation_response(response, model:)
+    end
+
     def paint(prompt, model:, size:, with:, params:)
       payload = render_image_payload(prompt, model:, size:, with:, params:)
       response = @connection.post images_url, payload
       parse_image_response(response, model:)
     end
 
+    def transcribe(audio_file, model:, language:, **options)
+      file_part = build_audio_file_part(audio_file)
+      payload = render_transcription_payload(file_part, model:, language:, **options)
+      response = @connection.post transcription_url, payload
+      parse_transcription_response(response, model:)
+    end
+
     def configured?
       configuration_requirements.all? { |req| @config.send(req) }
     end
@@ -162,9 +175,13 @@ module RubyLLM
         providers[name.to_sym] = provider_class
       end
 
+      def resolve(name)
+        providers[name.to_sym]
+      end
+
       def for(model)
         model_info = Models.find(model)
-        providers[model_info.provider.to_sym]
+        resolve model_info.provider
       end
 
       def providers
@@ -194,6 +211,17 @@ module RubyLLM
 
     private
 
+    def build_audio_file_part(file_path)
+      expanded_path = File.expand_path(file_path)
+      mime_type = Marcel::MimeType.for(Pathname.new(expanded_path))
+
+      Faraday::Multipart::FilePart.new(
+        expanded_path,
+        mime_type,
+        File.basename(expanded_path)
+      )
+    end
+
     def try_parse_json(maybe_json)
       return maybe_json unless maybe_json.is_a?(String)
 

data/lib/ruby_llm/providers/anthropic/chat.rb

@@ -74,15 +74,22 @@ module RubyLLM
         end
 
         def build_message(data, content, tool_use_blocks, response)
+          usage = data['usage'] || {}
+          cached_tokens = usage['cache_read_input_tokens']
+          cache_creation_tokens = usage['cache_creation_input_tokens']
+          if cache_creation_tokens.nil? && usage['cache_creation'].is_a?(Hash)
+            cache_creation_tokens = usage['cache_creation'].values.compact.sum
+          end
+
           Message.new(
             role: :assistant,
             content: content,
             tool_calls: Tools.parse_tool_calls(tool_use_blocks),
-            input_tokens: data.dig('usage', 'input_tokens'),
-            output_tokens: data.dig('usage', 'output_tokens'),
+            input_tokens: usage['input_tokens'],
+            output_tokens: usage['output_tokens'],
+            cached_tokens: cached_tokens,
+            cache_creation_tokens: cache_creation_tokens,
             model_id: data['model'],
-            cache_creation_tokens: data.dig('usage', 'cache_creation_input_tokens'),
-            cached_tokens: data.dig('usage', 'cache_read_input_tokens'),
             raw: response
           )
         end
@@ -98,7 +105,13 @@ module RubyLLM
         end
 
         def format_system_message(msg, cache: false)
-          Media.format_content(msg.content, cache:)
+          content = msg.content
+
+          if content.is_a?(RubyLLM::Content::Raw)
+            content.value
+          else
+            Media.format_content(content, cache:)
+          end
         end
 
         def format_basic_message(msg, cache: false)

data/lib/ruby_llm/providers/anthropic/content.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Anthropic
+      # Helper for constructing Anthropic native content blocks.
+      class Content
+        class << self
+          def new(text = nil, cache: false, cache_control: nil, parts: nil, **extras)
+            payload = resolve_payload(
+              text: text,
+              parts: parts,
+              cache: cache,
+              cache_control: cache_control,
+              extras: extras
+            )
+
+            RubyLLM::Content::Raw.new(payload)
+          end
+
+          private
+
+          def resolve_payload(text:, parts:, cache:, cache_control:, extras:)
+            return Array(parts) if parts
+
+            raise ArgumentError, 'text or parts must be provided' if text.nil?
+
+            block = { type: 'text', text: text }.merge(extras)
+            control = determine_cache_control(cache_control, cache)
+            block[:cache_control] = control if control
+
+            [block]
+          end
+
+          def determine_cache_control(cache_control, cache_flag)
+            return cache_control if cache_control
+
+            { type: 'ephemeral' } if cache_flag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/anthropic/media.rb

@@ -7,7 +7,8 @@ module RubyLLM
       module Media
         module_function
 
-        def format_content(content, cache: false)
+        def format_content(content, cache: false) # rubocop:disable Metrics/PerceivedComplexity
+          return content.value if content.is_a?(RubyLLM::Content::Raw)
           return [format_text(content.to_json, cache:)] if content.is_a?(Hash) || content.is_a?(Array)
           return [format_text(content, cache:)] unless content.is_a?(Content)
 
@@ -17,11 +18,11 @@ module RubyLLM
           content.attachments.each do |attachment|
             case attachment.type
             when :image
-              parts << format_image(attachment)
+              parts << format_image(attachment, cache:)
             when :pdf
-              parts << format_pdf(attachment)
+              parts << format_pdf(attachment, cache:)
             when :text
-              parts << format_text_file(attachment)
+              parts << format_text_file(attachment, cache:)
             else
               raise UnsupportedAttachmentError, attachment.mime_type
             end

data/lib/ruby_llm/providers/anthropic/models.rb

@@ -44,11 +44,18 @@ module RubyLLM
         end
 
         def extract_cached_tokens(data)
-          data.dig('message', 'usage', 'cache_read_input_tokens')
+          data.dig('message', 'usage', 'cache_read_input_tokens') || data.dig('usage', 'cache_read_input_tokens')
         end
 
         def extract_cache_creation_tokens(data)
-          data.dig('message', 'usage', 'cache_creation_input_tokens')
+          direct = data.dig('message', 'usage',
+                            'cache_creation_input_tokens') || data.dig('usage', 'cache_creation_input_tokens')
+          return direct if direct
+
+          breakdown = data.dig('message', 'usage', 'cache_creation') || data.dig('usage', 'cache_creation')
+          return unless breakdown.is_a?(Hash)
+
+          breakdown.values.compact.sum
         end
       end
     end

data/lib/ruby_llm/providers/anthropic/tools.rb

@@ -12,6 +12,8 @@ module RubyLLM
         end
 
         def format_tool_call(msg)
+          return { role: 'assistant', content: msg.content.value } if msg.content.is_a?(RubyLLM::Content::Raw)
+
           content = []
 
           content << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
@@ -29,7 +31,7 @@ module RubyLLM
         def format_tool_result(msg)
           {
             role: 'user',
-            content: [format_tool_result_block(msg)]
+            content: msg.content.is_a?(RubyLLM::Content::Raw) ? msg.content.value : [format_tool_result_block(msg)]
           }
         end
 
@@ -51,15 +53,18 @@ module RubyLLM
         end
 
         def function_for(tool)
-          {
+          input_schema = tool.params_schema ||
+                         RubyLLM::Tool::SchemaDefinition.from_parameters(tool.parameters)&.json_schema
+
+          declaration = {
             name: tool.name,
             description: tool.description,
-            input_schema: {
-              type: 'object',
-              properties: clean_parameters(tool.parameters),
-              required: required_parameters(tool.parameters)
-            }
+            input_schema: input_schema || default_input_schema
           }
+
+          return declaration if tool.provider_params.empty?
+
+          RubyLLM::Utils.deep_merge(declaration, tool.provider_params)
         end
 
         def extract_tool_calls(data)
@@ -89,17 +94,14 @@ module RubyLLM
           tool_calls.empty? ? nil : tool_calls
         end
 
-        def clean_parameters(parameters)
-          parameters.transform_values do |param|
-            {
-              type: param.type,
-              description: param.description
-            }.compact
-          end
-        end
-
-        def required_parameters(parameters)
-          parameters.select { |_, param| param.required }.keys
+        def default_input_schema
+          {
+            'type' => 'object',
+            'properties' => {},
+            'required' => [],
+            'additionalProperties' => false,
+            'strict' => true
+          }
         end
       end
     end

data/lib/ruby_llm/providers/bedrock/media.rb

@@ -10,7 +10,8 @@ module RubyLLM
 
         module_function
 
-        def format_content(content, cache: false)
+        def format_content(content, cache: false) # rubocop:disable Metrics/PerceivedComplexity
+          return content.value if content.is_a?(RubyLLM::Content::Raw)
           return [Anthropic::Media.format_text(content.to_json, cache:)] if content.is_a?(Hash) || content.is_a?(Array)
           return [Anthropic::Media.format_text(content, cache:)] unless content.is_a?(Content)
 

data/lib/ruby_llm/providers/bedrock/streaming/content_extraction.rb

@@ -33,11 +33,18 @@ module RubyLLM
           end
 
           def extract_cached_tokens(data)
-            data.dig('message', 'usage', 'cache_read_input_tokens')
+            data.dig('message', 'usage', 'cache_read_input_tokens') || data.dig('usage', 'cache_read_input_tokens')
           end
 
           def extract_cache_creation_tokens(data)
-            data.dig('message', 'usage', 'cache_creation_input_tokens')
+            direct = data.dig('message', 'usage',
+                              'cache_creation_input_tokens') || data.dig('usage', 'cache_creation_input_tokens')
+            return direct if direct
+
+            breakdown = data.dig('message', 'usage', 'cache_creation') || data.dig('usage', 'cache_creation')
+            return unless breakdown.is_a?(Hash)
+
+            breakdown.values.compact.sum
           end
 
           private