dify_llm 1.9.2 → 1.14.1

data/lib/ruby_llm/message.rb

@@ -5,22 +5,26 @@ module RubyLLM
   class Message
     ROLES = %i[system user assistant tool].freeze
 
-    attr_reader :role, :model_id, :tool_calls, :tool_call_id, :input_tokens, :output_tokens,
-                :cached_tokens, :cache_creation_tokens, :raw, :conversation_id
+    attr_reader :role, :model_id, :tool_calls, :tool_call_id, :raw, :conversation_id, :thinking, :tokens
     attr_writer :content
 
     def initialize(options = {})
       @role = options.fetch(:role).to_sym
-      @content = normalize_content(options.fetch(:content))
-      @model_id = options[:model_id]
       @tool_calls = options[:tool_calls]
+      @content = normalize_content(options.fetch(:content), role: @role, tool_calls: @tool_calls)
+      @model_id = options[:model_id]
       @tool_call_id = options[:tool_call_id]
-      @conversation_id = options[:conversation_id]
-      @input_tokens = options[:input_tokens]
-      @output_tokens = options[:output_tokens]
-      @cached_tokens = options[:cached_tokens]
-      @cache_creation_tokens = options[:cache_creation_tokens]
+      @tokens = options[:tokens] || Tokens.build(
+        input: options[:input_tokens],
+        output: options[:output_tokens],
+        cached: options[:cached_tokens],
+        cache_creation: options[:cache_creation_tokens],
+        thinking: options[:thinking_tokens],
+        reasoning: options[:reasoning_tokens]
+      )
       @raw = options[:raw]
+      @conversation_id = options[:conversation_id]
+      @thinking = options[:thinking]
 
       ensure_valid_role
     end
@@ -45,6 +49,30 @@ module RubyLLM
       content if tool_result?
     end
 
+    def input_tokens
+      tokens&.input
+    end
+
+    def output_tokens
+      tokens&.output
+    end
+
+    def cached_tokens
+      tokens&.cached
+    end
+
+    def cache_creation_tokens
+      tokens&.cache_creation
+    end
+
+    def thinking_tokens
+      tokens&.thinking
+    end
+
+    def reasoning_tokens
+      tokens&.thinking
+    end
+
     def to_h
       {
         role: role,
@@ -53,11 +81,9 @@ module RubyLLM
         tool_calls: tool_calls,
         tool_call_id: tool_call_id,
         conversation_id: conversation_id,
-        input_tokens: input_tokens,
-        output_tokens: output_tokens,
-        cached_tokens: cached_tokens,
-        cache_creation_tokens: cache_creation_tokens
-      }.compact
+        thinking: thinking&.text,
+        thinking_signature: thinking&.signature
+      }.merge(tokens ? tokens.to_h : {}).compact
     end
 
     def instance_variables
@@ -66,7 +92,9 @@ module RubyLLM
 
     private
 
-    def normalize_content(content)
+    def normalize_content(content, role:, tool_calls:)
+      return '' if role == :assistant && content.nil? && tool_calls && !tool_calls.empty?
+
       case content
       when String then Content.new(content)
       when Hash then Content.new(content[:text], content)

data/lib/ruby_llm/model/info.rb

@@ -24,7 +24,7 @@ module RubyLLM
         @name = data[:name]
         @provider = data[:provider]
         @family = data[:family]
-        @created_at = Utils.to_time(data[:created_at])
+        @created_at = Utils.to_time(data[:created_at])&.utc
         @context_window = data[:context_window]
         @max_output_tokens = data[:max_output_tokens]
         @knowledge_cutoff = Utils.to_date(data[:knowledge_cutoff])
@@ -48,6 +48,11 @@ module RubyLLM
         name
       end
 
+      def label
+        provider_name = provider_class&.name || provider
+        "#{provider_name} - #{display_name}"
+      end
+
       def max_tokens
         max_output_tokens
       end
@@ -76,18 +81,15 @@ module RubyLLM
         RubyLLM::Provider.resolve provider
       end
 
-      def type # rubocop:disable Metrics/PerceivedComplexity
-        if modalities.output.include?('embeddings') && !modalities.output.include?('text')
-          'embedding'
-        elsif modalities.output.include?('image') && !modalities.output.include?('text')
-          'image'
-        elsif modalities.output.include?('audio') && !modalities.output.include?('text')
-          'audio'
-        elsif modalities.output.include?('moderation')
-          'moderation'
-        else
-          'chat'
-        end
+      def type
+        output = modalities.output
+        return 'embedding' if output.include?('embeddings')
+        return 'moderation' if output.include?('moderation')
+        return 'image' if output.include?('image')
+        return 'audio' if output.include?('audio')
+        return 'video' if output.include?('video')
+
+        'chat'
       end
 
       def to_h