dify_llm 1.8.1 → 1.9.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

data/lib/ruby_llm/provider.rb

@@ -82,6 +82,13 @@ module RubyLLM
       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
@@ -160,9 +167,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
@@ -192,6 +203,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

@@ -25,6 +25,8 @@ module RubyLLM
         end
 
         def build_system_content(system_messages)
+          return [] if system_messages.empty?
+
           if system_messages.length > 1
             RubyLLM.logger.warn(
               "Anthropic's Claude implementation only supports a single system message. " \
@@ -32,7 +34,15 @@ module RubyLLM
             )
           end
 
-          system_messages.map(&:content).join("\n\n")
+          system_messages.flat_map do |msg|
+            content = msg.content
+
+            if content.is_a?(RubyLLM::Content::Raw)
+              content.value
+            else
+              Media.format_content(content)
+            end
+          end
         end
 
         def build_base_payload(chat_messages, model, stream)
@@ -66,12 +76,21 @@ 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'],
             raw: response
           )

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)
+        def format_content(content) # rubocop:disable Metrics/PerceivedComplexity
+          return content.value if content.is_a?(RubyLLM::Content::Raw)
           return [format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
           return [format_text(content)] unless content.is_a?(Content)
 

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

@@ -42,6 +42,21 @@ module RubyLLM
         def extract_output_tokens(data)
           data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens')
         end
+
+        def extract_cached_tokens(data)
+          data.dig('message', 'usage', 'cache_read_input_tokens') || data.dig('usage', 'cache_read_input_tokens')
+        end
+
+        def extract_cache_creation_tokens(data)
+          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
   end

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

@@ -18,6 +18,8 @@ module RubyLLM
             content: data.dig('delta', 'text'),
             input_tokens: extract_input_tokens(data),
             output_tokens: extract_output_tokens(data),
+            cached_tokens: extract_cached_tokens(data),
+            cache_creation_tokens: extract_cache_creation_tokens(data),
             tool_calls: extract_tool_calls(data)
           )
         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)
+        def format_content(content) # rubocop:disable Metrics/PerceivedComplexity
+          return content.value if content.is_a?(RubyLLM::Content::Raw)
           return [Anthropic::Media.format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
           return [Anthropic::Media.format_text(content)] unless content.is_a?(Content)
 

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

@@ -32,6 +32,21 @@ module RubyLLM
             data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens')
           end
 
+          def extract_cached_tokens(data)
+            data.dig('message', 'usage', 'cache_read_input_tokens') || data.dig('usage', 'cache_read_input_tokens')
+          end
+
+          def extract_cache_creation_tokens(data)
+            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
 
           def extract_content_by_type(data)

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

@@ -59,6 +59,8 @@ module RubyLLM
               content: extract_streaming_content(data),
               input_tokens: extract_input_tokens(data),
               output_tokens: extract_output_tokens(data),
+              cached_tokens: extract_cached_tokens(data),
+              cache_creation_tokens: extract_cache_creation_tokens(data),
               tool_calls: extract_tool_calls(data)
             }
           end

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

@@ -6,12 +6,23 @@ module RubyLLM
       # Chat methods of the Dify API integration
       module Chat
         def upload_document(document_path, original_filename = nil)
-          pn = Pathname.new(document_path)
+          path_like = if document_path.respond_to?(:path)
+                        document_path.path
+                      elsif document_path.respond_to?(:to_path)
+                        document_path.to_path
+                      else
+                        document_path
+                      end
+          pn = Pathname.new(path_like)
           mime_type = RubyLLM::MimeType.for pn
-          original_filename ||= document_path.is_a?(String) ? pn.basename : (document_path.is_a?(Tempfile) ? File.basename(document_path) : document_path.original_filename)
+          original_filename ||= if document_path.respond_to?(:original_filename)
+                                  document_path.original_filename
+                                else
+                                  pn.basename.to_s
+                                end
           payload = {
-            file: Faraday::Multipart::FilePart.new(document_path, mime_type, original_filename),
-            user: config.dify_user || 'dify-user'
+            file: Faraday::Multipart::FilePart.new(path_like, mime_type, original_filename),
+            user: (@config&.dify_user || 'dify-user')
           }
           @connection.upload('v1/files/upload', payload)
         end
@@ -34,7 +45,7 @@ module RubyLLM
             query: current_message_content.is_a?(Content) ? current_message_content.text : current_message_content,
             response_mode: (stream ? 'streaming' : 'blocking'),
             conversation_id: latest_conversation_id,
-            user: config.dify_user || 'dify-user',
+            user: (@config&.dify_user || 'dify-user'),
             files: format_files(current_message_content)
           }
         end