dify_llm 1.6.4 → 1.7.0

data/lib/ruby_llm/active_record/acts_as.rb

@@ -31,105 +31,135 @@ module RubyLLM
       end
 
       class_methods do # rubocop:disable Metrics/BlockLength
-        def acts_as_chat(message_class: 'Message', tool_call_class: 'ToolCall',
-                         model_class: 'Model', model_foreign_key: nil)
+        def acts_as_chat(messages: :messages, message_class: nil,
+                         model: :model, model_class: nil)
           include RubyLLM::ActiveRecord::ChatMethods
 
-          @message_class = message_class.to_s
-          @tool_call_class = tool_call_class.to_s
-          @model_class = model_class.to_s
-          @model_foreign_key = model_foreign_key || ActiveSupport::Inflector.foreign_key(@model_class)
+          class_attribute :messages_association_name, :model_association_name, :message_class, :model_class
 
-          has_many :messages,
+          self.messages_association_name = messages
+          self.model_association_name = model
+          self.message_class = (message_class || messages.to_s.classify).to_s
+          self.model_class = (model_class || model.to_s.classify).to_s
+
+          has_many messages,
                    -> { order(created_at: :asc) },
-                   class_name: @message_class,
-                   inverse_of: :chat,
+                   class_name: self.message_class,
                    dependent: :destroy
 
-          belongs_to :model,
-                     class_name: @model_class,
-                     foreign_key: @model_foreign_key,
+          belongs_to model,
+                     class_name: self.model_class,
                      optional: true
 
           delegate :add_message, to: :to_llm
+
+          define_method :messages_association do
+            send(messages_association_name)
+          end
+
+          define_method :model_association do
+            send(model_association_name)
+          end
+
+          define_method :'model_association=' do |value|
+            send("#{model_association_name}=", value)
+          end
         end
 
-        def acts_as_model(chat_class: 'Chat')
+        def acts_as_model(chats: :chats, chat_class: nil)
           include RubyLLM::ActiveRecord::ModelMethods
 
-          @chat_class = chat_class.to_s
+          class_attribute :chats_association_name, :chat_class
+
+          self.chats_association_name = chats
+          self.chat_class = (chat_class || chats.to_s.classify).to_s
 
           validates :model_id, presence: true, uniqueness: { scope: :provider }
           validates :provider, presence: true
           validates :name, presence: true
 
-          has_many :chats,
-                   class_name: @chat_class,
-                   foreign_key: ActiveSupport::Inflector.foreign_key(name)
+          has_many chats, class_name: self.chat_class
+
+          define_method :chats_association do
+            send(chats_association_name)
+          end
         end
 
-        def acts_as_message(chat_class: 'Chat', # rubocop:disable Metrics/ParameterLists
-                            chat_foreign_key: nil,
-                            tool_call_class: 'ToolCall',
-                            tool_call_foreign_key: nil,
-                            model_class: 'Model',
-                            model_foreign_key: nil,
-                            touch_chat: false)
+        def acts_as_message(chat: :chat, chat_class: nil, touch_chat: false, # rubocop:disable Metrics/ParameterLists
+                            tool_calls: :tool_calls, tool_call_class: nil,
+                            model: :model, model_class: nil)
           include RubyLLM::ActiveRecord::MessageMethods
 
-          @chat_class = chat_class.to_s
-          @chat_foreign_key = chat_foreign_key || ActiveSupport::Inflector.foreign_key(@chat_class)
-
-          @tool_call_class = tool_call_class.to_s
-          @tool_call_foreign_key = tool_call_foreign_key || ActiveSupport::Inflector.foreign_key(@tool_call_class)
+          class_attribute :chat_association_name, :tool_calls_association_name, :model_association_name,
+                          :chat_class, :tool_call_class, :model_class
 
-          @model_class = model_class.to_s
-          @model_foreign_key = model_foreign_key || ActiveSupport::Inflector.foreign_key(@model_class)
+          self.chat_association_name = chat
+          self.tool_calls_association_name = tool_calls
+          self.model_association_name = model
+          self.chat_class = (chat_class || chat.to_s.classify).to_s
+          self.tool_call_class = (tool_call_class || tool_calls.to_s.classify).to_s
+          self.model_class = (model_class || model.to_s.classify).to_s
 
-          belongs_to :chat,
-                     class_name: @chat_class,
-                     foreign_key: @chat_foreign_key,
-                     inverse_of: :messages,
+          belongs_to chat,
+                     class_name: self.chat_class,
                      touch: touch_chat
 
-          has_many :tool_calls,
-                   class_name: @tool_call_class,
+          has_many tool_calls,
+                   class_name: self.tool_call_class,
                    dependent: :destroy
 
           belongs_to :parent_tool_call,
-                     class_name: @tool_call_class,
-                     foreign_key: @tool_call_foreign_key,
-                     optional: true,
-                     inverse_of: :result
+                     class_name: self.tool_call_class,
+                     foreign_key: ActiveSupport::Inflector.foreign_key(tool_calls.to_s.singularize),
+                     optional: true
 
           has_many :tool_results,
-                   through: :tool_calls,
+                   through: tool_calls,
                    source: :result,
-                   class_name: @message_class
+                   class_name: name
 
-          belongs_to :model,
-                     class_name: @model_class,
-                     foreign_key: @model_foreign_key,
+          belongs_to model,
+                     class_name: self.model_class,
                      optional: true
 
           delegate :tool_call?, :tool_result?, to: :to_llm
+
+          define_method :chat_association do
+            send(chat_association_name)
+          end
+
+          define_method :tool_calls_association do
+            send(tool_calls_association_name)
+          end
+
+          define_method :model_association do
+            send(model_association_name)
+          end
         end
 
-        def acts_as_tool_call(message_class: 'Message', message_foreign_key: nil, result_foreign_key: nil)
-          @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)
+        def acts_as_tool_call(message: :message, message_class: nil,
+                              result: :result, result_class: nil)
+          class_attribute :message_association_name, :result_association_name, :message_class, :result_class
 
-          belongs_to :message,
-                     class_name: @message_class,
-                     foreign_key: @message_foreign_key,
-                     inverse_of: :tool_calls
+          self.message_association_name = message
+          self.result_association_name = result
+          self.message_class = (message_class || message.to_s.classify).to_s
+          self.result_class = (result_class || self.message_class).to_s
 
-          has_one :result,
-                  class_name: @message_class,
-                  foreign_key: @result_foreign_key,
-                  inverse_of: :parent_tool_call,
+          belongs_to message,
+                     class_name: self.message_class
+
+          has_one result,
+                  class_name: self.result_class,
                   dependent: :nullify
+
+          define_method :message_association do
+            send(message_association_name)
+          end
+
+          define_method :result_association do
+            send(result_association_name)
+          end
         end
       end
     end

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -10,15 +10,17 @@ module RubyLLM
         before_save :resolve_model_from_strings
       end
 
-      class_methods do
-        attr_reader :tool_call_class, :model_class
-      end
-
       attr_accessor :assume_model_exists, :context
 
       def model=(value)
         @model_string = value if value.is_a?(String)
-        super unless value.is_a?(String)
+        return if value.is_a?(String)
+
+        if self.class.model_association_name == :model
+          super
+        else
+          self.model_association = value
+        end
       end
 
       def model_id=(value)
@@ -26,7 +28,7 @@ module RubyLLM
       end
 
       def model_id
-        model&.model_id
+        model_association&.model_id
       end
 
       def provider=(value)
@@ -34,19 +36,21 @@ module RubyLLM
       end
 
       def provider
-        model&.provider
+        model_association&.provider
       end
 
       private
 
       def resolve_model_from_strings # rubocop:disable Metrics/PerceivedComplexity
+        config = context&.config || RubyLLM.config
+        @model_string ||= config.default_model unless model_association
         return unless @model_string
 
         model_info, _provider = Models.resolve(
           @model_string,
           provider: @provider_string,
           assume_exists: assume_model_exists || false,
-          config: context&.config || RubyLLM.config
+          config: config
         )
 
         model_class = self.class.model_class.constantize
@@ -64,7 +68,7 @@ module RubyLLM
           m.metadata = model_info.metadata || {}
         end
 
-        self.model = model_record
+        self.model_association = model_record
         @model_string = nil
         @provider_string = nil
       end
@@ -72,15 +76,14 @@ module RubyLLM
       public
 
       def to_llm
-        raise 'No model specified' unless model
-
+        model_record = model_association
         @chat ||= (context || RubyLLM).chat(
-          model: model.model_id,
-          provider: model.provider.to_sym
+          model: model_record.model_id,
+          provider: model_record.provider.to_sym
         )
         @chat.reset_messages!
 
-        messages.each do |msg|
+        messages_association.each do |msg|
           @chat.add_message(msg.to_llm)
         end
 
@@ -89,8 +92,8 @@ module RubyLLM
 
       def with_instructions(instructions, replace: false)
         transaction do
-          messages.where(role: :system).destroy_all if replace
-          messages.create!(role: :system, content: instructions)
+          messages_association.where(role: :system).destroy_all if replace
+          messages_association.create!(role: :system, content: instructions)
         end
         to_llm.with_instructions(instructions)
         self
@@ -106,12 +109,13 @@ module RubyLLM
         self
       end
 
-      def with_model(model_name, provider: nil)
-        self.provider = provider if provider
+      def with_model(model_name, provider: nil, assume_exists: false)
         self.model = model_name
+        self.provider = provider if provider
+        self.assume_model_exists = assume_exists
         resolve_model_from_strings
         save!
-        to_llm.with_model(model.model_id, provider: model.provider.to_sym)
+        to_llm.with_model(model.model_id, provider: model.provider.to_sym, assume_exists:)
         self
       end
 
@@ -170,7 +174,7 @@ module RubyLLM
       end
 
       def create_user_message(content, with: nil)
-        message_record = messages.create!(role: :user, content: content)
+        message_record = messages_association.create!(role: :user, content: content)
         persist_content(message_record, with) if with.present?
         message_record
       end
@@ -198,8 +202,8 @@ module RubyLLM
       end
 
       def cleanup_orphaned_tool_results # rubocop:disable Metrics/PerceivedComplexity
-        messages.reload
-        last = messages.order(:id).last
+        messages_association.reload
+        last = messages_association.order(:id).last
 
         return unless last&.tool_call? || last&.tool_result?
 
@@ -228,7 +232,7 @@ module RubyLLM
       end
 
       def persist_new_message
-        @message = messages.create!(role: :assistant, content: '')
+        @message = messages_association.create!(role: :assistant, content: '')
       end
 
       def persist_message_completion(message) # rubocop:disable Metrics/PerceivedComplexity
@@ -247,15 +251,22 @@ module RubyLLM
             content = content.to_json
           end
 
-          @message.update!(
+          attrs = {
             role: message.role,
             content: content,
-            model: model,
             input_tokens: message.input_tokens,
             output_tokens: message.output_tokens
-          )
-          @message.write_attribute(@message.class.tool_call_foreign_key, tool_call_id) if tool_call_id
-          @message.save!
+          }
+
+          # Add model association dynamically
+          attrs[self.class.model_association_name] = model_association
+
+          if tool_call_id
+            parent_tool_call_assoc = @message.class.reflect_on_association(:parent_tool_call)
+            attrs[parent_tool_call_assoc.foreign_key] = tool_call_id
+          end
+
+          @message.update!(attrs)
 
           persist_content(@message, attachments_to_persist) if attachments_to_persist
           persist_tool_calls(message.tool_calls) if message.tool_calls.present?
@@ -266,12 +277,22 @@ module RubyLLM
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
           attributes[:tool_call_id] = attributes.delete(:id)
-          @message.tool_calls.create!(**attributes)
+          @message.tool_calls_association.create!(**attributes)
         end
       end
 
       def find_tool_call_id(tool_call_id)
-        self.class.tool_call_class.constantize.find_by(tool_call_id: tool_call_id)&.id
+        messages = messages_association
+        message_class = messages.klass
+        tool_calls_assoc = message_class.tool_calls_association_name
+        tool_call_table_name = message_class.reflect_on_association(tool_calls_assoc).table_name
+
+        message_with_tool_call = messages.joins(tool_calls_assoc)
+                                         .find_by(tool_call_table_name => { tool_call_id: tool_call_id })
+        return nil unless message_with_tool_call
+
+        tool_call = message_with_tool_call.tool_calls_association.find_by(tool_call_id: tool_call_id)
+        tool_call&.id
       end
 
       def persist_content(message_record, attachments)

data/lib/ruby_llm/active_record/message_methods.rb

@@ -18,14 +18,14 @@ module RubyLLM
           tool_call_id: extract_tool_call_id,
           input_tokens: input_tokens,
           output_tokens: output_tokens,
-          model_id: model_id
+          model_id: model_association&.model_id
         )
       end
 
       private
 
       def extract_tool_calls
-        tool_calls.to_h do |tool_call|
+        tool_calls_association.to_h do |tool_call|
           [
             tool_call.tool_call_id,
             RubyLLM::ToolCall.new(

data/lib/ruby_llm/aliases.json

@@ -227,14 +227,6 @@
     "openai": "gpt-5-nano",
     "openrouter": "openai/gpt-5-nano"
   },
-  "gpt-oss-120b": {
-    "openai": "gpt-oss-120b",
-    "openrouter": "openai/gpt-oss-120b"
-  },
-  "gpt-oss-20b": {
-    "openai": "gpt-oss-20b",
-    "openrouter": "openai/gpt-oss-20b"
-  },
   "o1": {
     "openai": "o1",
     "openrouter": "openai/o1"

data/lib/ruby_llm/configuration.rb

@@ -32,6 +32,8 @@ module RubyLLM
                   :default_image_model,
                   # Model registry
                   :model_registry_class,
+                  # Rails integration
+                  :use_new_acts_as,
                   # Connection configuration
                   :request_timeout,
                   :max_retries,
@@ -57,6 +59,9 @@ module RubyLLM
       @default_embedding_model = 'text-embedding-3-small'
       @default_image_model = 'gpt-image-1'
 
+      @model_registry_class = 'Model'
+      @use_new_acts_as = false
+
       @log_file = $stdout
       @log_level = ENV['RUBYLLM_DEBUG'] ? Logger::DEBUG : Logger::INFO
       @log_stream_debug = ENV['RUBYLLM_STREAM_DEBUG'] == 'true'