dify_llm 1.9.1 → 1.14.1

data/lib/ruby_llm/active_record/acts_as_legacy.rb

@@ -18,8 +18,6 @@ module RubyLLM
                    class_name: @message_class,
                    inverse_of: :chat,
                    dependent: :destroy
-
-          delegate :add_message, to: :to_llm
         end
 
         def acts_as_message(chat_class: 'Chat',
@@ -60,6 +58,8 @@ module RubyLLM
         end
 
         def acts_as_tool_call(message_class: 'Message', message_foreign_key: nil, result_foreign_key: nil)
+          include RubyLLM::ActiveRecord::ToolCallMethods
+
           @message_class = message_class.to_s
           @message_foreign_key = message_foreign_key || ActiveSupport::Inflector.foreign_key(@message_class)
           @result_foreign_key = result_foreign_key || ActiveSupport::Inflector.foreign_key(name)
@@ -95,19 +95,28 @@ module RubyLLM
                   end
         @chat.reset_messages!
 
-        messages.each do |msg|
+        ordered_messages = order_messages_for_llm(messages.to_a)
+        ordered_messages.each do |msg|
           @chat.add_message(msg.to_llm)
         end
+        reapply_runtime_instructions(@chat)
 
         setup_persistence_callbacks
       end
 
-      def with_instructions(instructions, replace: false)
-        transaction do
-          messages.where(role: :system).destroy_all if replace
-          messages.create!(role: :system, content: instructions)
-        end
-        to_llm.with_instructions(instructions)
+      def with_instructions(instructions, append: false, replace: nil)
+        append = append_instructions?(append:, replace:)
+        persist_system_instruction(instructions, append:)
+
+        to_llm.with_instructions(instructions, append:, replace:)
+        self
+      end
+
+      def with_runtime_instructions(instructions, append: false, replace: nil)
+        append = append_instructions?(append:, replace:)
+        store_runtime_instruction(instructions, append:)
+
+        to_llm.with_instructions(instructions, append:, replace:)
         self
       end
 
@@ -185,14 +194,34 @@ module RubyLLM
         self
       end
 
-      def create_user_message(content, with: nil)
-        message_record = messages.create!(role: :user, content: content)
-        persist_content(message_record, with) if with.present?
+      def add_message(message_or_attributes)
+        llm_message = message_or_attributes.is_a?(RubyLLM::Message) ? message_or_attributes : RubyLLM::Message.new(message_or_attributes)
+        content, attachments_to_persist = prepare_content_for_storage(llm_message.content)
+
+        attrs = { role: llm_message.role, content: }
+        tool_call_foreign_key = messages.klass.tool_call_foreign_key
+        if llm_message.tool_call_id && tool_call_foreign_key
+          tool_call_id = find_tool_call_id(llm_message.tool_call_id)
+          attrs[tool_call_foreign_key] = tool_call_id if tool_call_id
+        end
+
+        message_record = messages.create!(attrs)
+        persist_content(message_record, attachments_to_persist) if attachments_to_persist.present?
+        persist_tool_calls(llm_message.tool_calls, message_record:) if llm_message.tool_calls.present?
+
         message_record
       end
 
-      def ask(message, with: nil, &)
-        create_user_message(message, with:)
+      def create_user_message(content, with: nil)
+        RubyLLM.logger.warn(
+          '`create_user_message` is deprecated and will be removed in RubyLLM 2.0. ' \
+          'Use `add_message(role: :user, content: ...)` instead.'
+        )
+        add_message(role: :user, content: build_content(content, with))
+      end
+
+      def ask(message = nil, with: nil, &)
+        add_message(role: :user, content: build_content(message, with))
         complete(&)
       end
 
@@ -233,6 +262,60 @@ module RubyLLM
         end
       end
 
+      def replace_persisted_system_instructions(instructions)
+        system_messages = messages.where(role: :system).order(:id).to_a
+
+        if system_messages.empty?
+          messages.create!(role: :system, content: instructions)
+          return
+        end
+
+        primary_message = system_messages.shift
+        primary_message.update!(content: instructions) if primary_message.content != instructions
+        system_messages.each(&:destroy!)
+      end
+
+      def append_instructions?(append:, replace:)
+        return append if replace.nil?
+
+        append || (replace == false)
+      end
+
+      def persist_system_instruction(instructions, append:)
+        transaction do
+          if append
+            messages.create!(role: :system, content: instructions)
+          else
+            replace_persisted_system_instructions(instructions)
+          end
+        end
+      end
+
+      def order_messages_for_llm(messages)
+        system_messages, non_system_messages = messages.partition { |msg| msg.role.to_s == 'system' }
+        system_messages + non_system_messages
+      end
+
+      def runtime_instructions
+        @runtime_instructions ||= []
+      end
+
+      def store_runtime_instruction(instructions, append:)
+        if append
+          runtime_instructions << instructions
+        else
+          @runtime_instructions = [instructions]
+        end
+      end
+
+      def reapply_runtime_instructions(chat)
+        return if runtime_instructions.empty?
+
+        first, *rest = runtime_instructions
+        chat.with_instructions(first)
+        rest.each { |instruction| chat.with_instructions(instruction, append: true) }
+      end
+
       def setup_persistence_callbacks
         return @chat if @chat.instance_variable_get(:@_persistence_callbacks_setup)
 
@@ -247,21 +330,13 @@ module RubyLLM
         @message = messages.create!(role: :assistant, content: '')
       end
 
-      def persist_message_completion(message) # rubocop:disable Metrics/PerceivedComplexity
+      def persist_message_completion(message)
         return unless message
 
         tool_call_id = find_tool_call_id(message.tool_call_id) if message.tool_call_id
 
         transaction do
-          content = message.content
-          attachments_to_persist = nil
-
-          if content.is_a?(RubyLLM::Content)
-            attachments_to_persist = content.attachments if content.attachments.any?
-            content = content.text
-          elsif content.is_a?(Hash) || content.is_a?(Array)
-            content = content.to_json
-          end
+          content, attachments_to_persist = prepare_content_for_storage(message.content)
 
           @message.update!(
             role: message.role,
@@ -278,11 +353,17 @@ module RubyLLM
         end
       end
 
-      def persist_tool_calls(tool_calls)
+      def persist_tool_calls(tool_calls, message_record: @message)
+        tool_call_assoc = message_record.respond_to?(:tool_calls) ? message_record.tool_calls : nil
+        return unless tool_call_assoc
+
+        supports_thought_signature = tool_call_assoc.klass.column_names.include?('thought_signature')
+
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
+          attributes.delete(:thought_signature) unless supports_thought_signature
           attributes[:tool_call_id] = attributes.delete(:id)
-          @message.tool_calls.create!(**attributes)
+          tool_call_assoc.create!(**attributes)
         end
       end
 
@@ -326,6 +407,29 @@ module RubyLLM
         RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
         nil
       end
+
+      def build_content(message, attachments)
+        return message if content_like?(message)
+
+        RubyLLM::Content.new(message, attachments)
+      end
+
+      def content_like?(object)
+        object.is_a?(RubyLLM::Content) || object.is_a?(RubyLLM::Content::Raw)
+      end
+
+      def prepare_content_for_storage(content)
+        attachments = nil
+
+        if content.is_a?(RubyLLM::Content)
+          attachments = content.attachments if content.attachments.any?
+          [content.text, attachments]
+        elsif content.is_a?(Hash) || content.is_a?(Array)
+          [content.to_json, attachments]
+        else
+          [content, attachments]
+        end
+      end
     end
 
     # Methods mixed into message models.
@@ -357,7 +461,8 @@ module RubyLLM
             RubyLLM::ToolCall.new(
               id: tool_call.tool_call_id,
               name: tool_call.name,
-              arguments: tool_call.arguments
+              arguments: tool_call.arguments,
+              thought_signature: tool_call.try(:thought_signature)
             )
           ]
         end

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -79,23 +79,33 @@ module RubyLLM
         model_record = model_association
         @chat ||= (context || RubyLLM).chat(
           model: model_record.model_id,
-          provider: model_record.provider.to_sym
+          provider: model_record.provider.to_sym,
+          assume_model_exists: assume_model_exists || false
         )
         @chat.reset_messages!
 
-        messages_association.each do |msg|
+        ordered_messages = order_messages_for_llm(messages_association.to_a)
+        ordered_messages.each do |msg|
           @chat.add_message(msg.to_llm)
         end
+        reapply_runtime_instructions(@chat)
 
         setup_persistence_callbacks
       end
 
-      def with_instructions(instructions, replace: false)
-        transaction do
-          messages_association.where(role: :system).destroy_all if replace
-          messages_association.create!(role: :system, content: instructions)
-        end
-        to_llm.with_instructions(instructions)
+      def with_instructions(instructions, append: false, replace: nil)
+        append = append_instructions?(append:, replace:)
+        persist_system_instruction(instructions, append:)
+
+        to_llm.with_instructions(instructions, append:, replace:)
+        self
+      end
+
+      def with_runtime_instructions(instructions, append: false, replace: nil)
+        append = append_instructions?(append:, replace:)
+        store_runtime_instruction(instructions, append:)
+
+        to_llm.with_instructions(instructions, append:, replace:)
         self
       end
 
@@ -115,7 +125,7 @@ module RubyLLM
         self.assume_model_exists = assume_exists
         resolve_model_from_strings
         save!
-        to_llm.with_model(model.model_id, provider: model.provider.to_sym, assume_exists:)
+        to_llm.with_model(model_association.model_id, provider: model_association.provider.to_sym, assume_exists:)
         self
       end
 
@@ -124,6 +134,11 @@ module RubyLLM
         self
       end
 
+      def with_thinking(...)
+        to_llm.with_thinking(...)
+        self
+      end
+
       def with_params(...)
         to_llm.with_params(...)
         self
@@ -173,22 +188,32 @@ module RubyLLM
         self
       end
 
-      def create_user_message(content, with: nil)
-        content_text, attachments, content_raw = prepare_content_for_storage(content)
+      def add_message(message_or_attributes)
+        llm_message = message_or_attributes.is_a?(RubyLLM::Message) ? message_or_attributes : RubyLLM::Message.new(message_or_attributes)
+        content_text, attachments, content_raw = prepare_content_for_storage(llm_message.content)
+
+        attrs = { role: llm_message.role, content: content_text }
+        parent_tool_call_assoc = messages_association.klass.reflect_on_association(:parent_tool_call)
+        if parent_tool_call_assoc && llm_message.tool_call_id
+          tool_call_id = find_tool_call_id(llm_message.tool_call_id)
+          attrs[parent_tool_call_assoc.foreign_key] = tool_call_id if tool_call_id
+        end
 
-        message_record = messages_association.build(role: :user)
-        message_record.content = content_text
-        message_record.content_raw = content_raw if message_record.respond_to?(:content_raw=)
-        message_record.save!
+        message_record = messages_association.create!(attrs)
+        message_record.update!(content_raw:) if message_record.respond_to?(:content_raw=)
 
-        persist_content(message_record, with) if with.present?
         persist_content(message_record, attachments) if attachments.present?
+        persist_tool_calls(llm_message.tool_calls, message_record:) if llm_message.tool_calls.present?
 
         message_record
       end
 
-      def ask(message, with: nil, &)
-        create_user_message(message, with:)
+      def create_user_message(content, with: nil)
+        add_message(role: :user, content: build_content(content, with))
+      end
+
+      def ask(message = nil, with: nil, &)
+        add_message(role: :user, content: build_content(message, with))
         complete(&)
       end
 
@@ -218,9 +243,10 @@ module RubyLLM
         if last.tool_call?
           last.destroy
         elsif last.tool_result?
-          tool_call_message = last.parent_tool_call.message
-          expected_results = tool_call_message.tool_calls.pluck(:id)
-          actual_results = tool_call_message.tool_results.pluck(:tool_call_id)
+          tool_call_message = last.parent_tool_call.message_association
+          expected_results = tool_call_message.tool_calls_association.pluck(:id)
+          fk_column = tool_call_message.class.reflections['tool_results'].foreign_key
+          actual_results = tool_call_message.tool_results.pluck(fk_column)
 
           if expected_results.sort != actual_results.sort
             tool_call_message.tool_results.each(&:destroy)
@@ -239,6 +265,60 @@ module RubyLLM
         @chat
       end
 
+      def replace_persisted_system_instructions(instructions)
+        system_messages = messages_association.where(role: :system).order(:id).to_a
+
+        if system_messages.empty?
+          messages_association.create!(role: :system, content: instructions)
+          return
+        end
+
+        primary_message = system_messages.shift
+        primary_message.update!(content: instructions) if primary_message.content != instructions
+        system_messages.each(&:destroy!)
+      end
+
+      def append_instructions?(append:, replace:)
+        return append if replace.nil?
+
+        append || (replace == false)
+      end
+
+      def persist_system_instruction(instructions, append:)
+        transaction do
+          if append
+            messages_association.create!(role: :system, content: instructions)
+          else
+            replace_persisted_system_instructions(instructions)
+          end
+        end
+      end
+
+      def order_messages_for_llm(messages)
+        system_messages, non_system_messages = messages.partition { |msg| msg.role.to_s == 'system' }
+        system_messages + non_system_messages
+      end
+
+      def runtime_instructions
+        @runtime_instructions ||= []
+      end
+
+      def store_runtime_instruction(instructions, append:)
+        if append
+          runtime_instructions << instructions
+        else
+          @runtime_instructions = [instructions]
+        end
+      end
+
+      def reapply_runtime_instructions(chat)
+        return if runtime_instructions.empty?
+
+        first, *rest = runtime_instructions
+        chat.with_instructions(first)
+        rest.each { |instruction| chat.with_instructions(instruction, append: true) }
+      end
+
       def persist_new_message
         @message = messages_association.create!(role: :assistant, content: '')
       end
@@ -262,6 +342,9 @@ module RubyLLM
           if @message.has_attribute?(:cache_creation_tokens)
             attrs[:cache_creation_tokens] = message.cache_creation_tokens
           end
+          attrs[:thinking_text] = message.thinking&.text if @message.has_attribute?(:thinking_text)
+          attrs[:thinking_signature] = message.thinking&.signature if @message.has_attribute?(:thinking_signature)
+          attrs[:thinking_tokens] = message.thinking_tokens if @message.has_attribute?(:thinking_tokens)
 
           # Add model association dynamically
           attrs[self.class.model_association_name] = model_association
@@ -281,11 +364,15 @@ module RubyLLM
       end
       # rubocop:enable Metrics/PerceivedComplexity
 
-      def persist_tool_calls(tool_calls)
+      def persist_tool_calls(tool_calls, message_record: @message)
+        tool_call_klass = message_record.tool_calls_association.klass
+        supports_thought_signature = tool_call_klass.column_names.include?('thought_signature')
+
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
+          attributes.delete(:thought_signature) unless supports_thought_signature
           attributes[:tool_call_id] = attributes.delete(:id)
-          @message.tool_calls_association.create!(**attributes)
+          message_record.tool_calls_association.create!(**attributes)
         end
       end
 
@@ -330,16 +417,33 @@ module RubyLLM
 
         attachment = source.is_a?(RubyLLM::Attachment) ? source : RubyLLM::Attachment.new(source)
 
-        {
-          io: StringIO.new(attachment.content),
-          filename: attachment.filename,
-          content_type: attachment.mime_type
-        }
+        if attachment.active_storage?
+          case attachment.source
+          when ActiveStorage::Blob then attachment.source
+          when ActiveStorage::Attached::One, ActiveStorage::Attached::Many then attachment.source.blobs
+          end
+        else
+          {
+            io: StringIO.new(attachment.content),
+            filename: attachment.filename,
+            content_type: attachment.mime_type
+          }
+        end
       rescue StandardError => e
         RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
         nil
       end
 
+      def build_content(message, attachments)
+        return message if content_like?(message)
+
+        RubyLLM::Content.new(message, attachments)
+      end
+
+      def content_like?(object)
+        object.is_a?(RubyLLM::Content) || object.is_a?(RubyLLM::Content::Raw)
+      end
+
       def prepare_content_for_storage(content)
         attachments = nil
         content_raw = nil

data/lib/ruby_llm/active_record/message_methods.rb

@@ -5,30 +5,79 @@ module RubyLLM
     # Methods mixed into message models.
     module MessageMethods
       extend ActiveSupport::Concern
+      include PayloadHelpers
 
       class_methods do
         attr_reader :chat_class, :tool_call_class, :chat_foreign_key, :tool_call_foreign_key
       end
 
       def to_llm
-        cached = has_attribute?(:cached_tokens) ? self[:cached_tokens] : nil
-        cache_creation = has_attribute?(:cache_creation_tokens) ? self[:cache_creation_tokens] : nil
-
         RubyLLM::Message.new(
           role: role.to_sym,
           content: extract_content,
+          thinking: thinking,
+          tokens: tokens,
           tool_calls: extract_tool_calls,
           tool_call_id: extract_tool_call_id,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          cached_tokens: cached,
-          cache_creation_tokens: cache_creation,
           model_id: model_association&.model_id
         )
       end
 
+      def thinking
+        RubyLLM::Thinking.build(
+          text: thinking_text_value,
+          signature: thinking_signature_value
+        )
+      end
+
+      def tokens
+        RubyLLM::Tokens.build(
+          input: input_tokens,
+          output: output_tokens,
+          cached: cached_value,
+          cache_creation: cache_creation_value,
+          thinking: thinking_tokens_value
+        )
+      end
+
+      def to_partial_path
+        partial_prefix = self.class.name.underscore.pluralize
+        role_partial = if to_llm.tool_call?
+                         'tool_calls'
+                       elsif role.to_s == 'tool'
+                         'tool'
+                       else
+                         role.to_s.presence || 'assistant'
+                       end
+        "#{partial_prefix}/#{role_partial}"
+      end
+
+      def tool_error_message
+        payload_error_message(content)
+      end
+
       private
 
+      def thinking_text_value
+        has_attribute?(:thinking_text) ? self[:thinking_text] : nil
+      end
+
+      def thinking_signature_value
+        has_attribute?(:thinking_signature) ? self[:thinking_signature] : nil
+      end
+
+      def cached_value
+        has_attribute?(:cached_tokens) ? self[:cached_tokens] : nil
+      end
+
+      def cache_creation_value
+        has_attribute?(:cache_creation_tokens) ? self[:cache_creation_tokens] : nil
+      end
+
+      def thinking_tokens_value
+        has_attribute?(:thinking_tokens) ? self[:thinking_tokens] : nil
+      end
+
       def extract_tool_calls
         tool_calls_association.to_h do |tool_call|
           [
@@ -36,7 +85,8 @@ module RubyLLM
             RubyLLM::ToolCall.new(
               id: tool_call.tool_call_id,
               name: tool_call.name,
-              arguments: tool_call.arguments
+              arguments: tool_call.arguments,
+              thought_signature: tool_call.try(:thought_signature)
             )
           ]
         end

data/lib/ruby_llm/active_record/model_methods.rb

@@ -77,7 +77,7 @@ module RubyLLM
       delegate :supports?, :supports_vision?, :supports_functions?, :type,
                :input_price_per_million, :output_price_per_million,
                :function_calling?, :structured_output?, :batch?,
-               :reasoning?, :citations?, :streaming?, :provider_class,
+               :reasoning?, :citations?, :streaming?, :provider_class, :label,
                to: :to_llm
     end
   end

data/lib/ruby_llm/active_record/payload_helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ActiveRecord
+    # Shared helpers for parsing serialized payloads on ActiveRecord-backed models.
+    module PayloadHelpers
+      private
+
+      def payload_error_message(value)
+        payload = parse_payload(value)
+        return unless payload.is_a?(Hash)
+
+        payload['error'] || payload[:error]
+      end
+
+      def parse_payload(value)
+        return value if value.is_a?(Hash) || value.is_a?(Array)
+        return if value.blank?
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_llm/active_record/tool_call_methods.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ActiveRecord
+    # Methods mixed into tool call models.
+    module ToolCallMethods
+      extend ActiveSupport::Concern
+      include PayloadHelpers
+
+      def tool_error_message
+        payload_error_message(arguments)
+      end
+    end
+  end
+end