Fix callback persistence chaining using Fanout pattern

- Implements `CallbackFanout` in `RubyLLM::Chat` to allow multiple callbacks per event.
- Removes brittle wrapper workarounds in ActiveRecord integrations.
- Ensures persistence callbacks are not overwritten when users define custom callbacks on the underlying LLM object.
- Adds regression test for direct callback chaining.

Author: kieranklaassen

lib/ruby_llm/active_record/acts_as_legacy.rb

@@ -152,26 +152,12 @@ def with_schema(...)
       end
 
       def on_new_message(&block)
-        to_llm
-
-        existing_callback = @chat.instance_variable_get(:@on)[:new_message]
-
-        @chat.on_new_message do
-          existing_callback&.call
-          block&.call
-        end
+        to_llm.on_new_message(&block)
         self
       end
 
       def on_end_message(&block)
-        to_llm
-
-        existing_callback = @chat.instance_variable_get(:@on)[:end_message]
-
-        @chat.on_end_message do |msg|
-          existing_callback&.call(msg)
-          block&.call(msg)
-        end
+        to_llm.on_end_message(&block)
         self
       end
 

lib/ruby_llm/active_record/chat_methods.rb

@@ -140,26 +140,12 @@ def with_schema(...)
       end
 
       def on_new_message(&block)
-        to_llm
-
-        existing_callback = @chat.instance_variable_get(:@on)[:new_message]
-
-        @chat.on_new_message do
-          existing_callback&.call
-          block&.call
-        end
+        to_llm.on_new_message(&block)
         self
       end
 
       def on_end_message(&block)
-        to_llm
-
-        existing_callback = @chat.instance_variable_get(:@on)[:end_message]
-
-        @chat.on_end_message do |msg|
-          existing_callback&.call(msg)
-          block&.call(msg)
-        end
+        to_llm.on_end_message(&block)
         self
       end
 

lib/ruby_llm/chat.rb

@@ -7,6 +7,34 @@ class Chat
 
     attr_reader :model, :messages, :tools, :params, :headers, :schema
 
+    # Hash-like container that stores arrays of callables and fans out calls to all of them
+    class CallbackFanout
+      def initialize
+        @callbacks = {}
+      end
+
+      # @return [Proc, nil] A callable that fans out to all callables in order
+      def [](key)
+        callables = Array(@callbacks[key]).compact
+        return nil if callables.empty?
+
+        # Return a callable that fans out to all callables in order
+        lambda do |*args, **kwargs, &block|
+          callables.each { |c| c.call(*args, **kwargs, &block) }
+        end
+      end
+
+      # Appends the callable to the array instead of overwriting
+      def []=(key, callable)
+        return if callable.nil?
+
+        raise ArgumentError, 'The callback must be callable' unless callable.respond_to?(:call)
+
+        @callbacks[key] ||= []
+        @callbacks[key] << callable
+      end
+    end
+
     def initialize(model: nil, provider: nil, assume_model_exists: false, context: nil)
       if assume_model_exists && !provider
         raise ArgumentError, 'Provider must be specified if assume_model_exists is true'
@@ -22,12 +50,7 @@ def initialize(model: nil, provider: nil, assume_model_exists: false, context: n
       @params = {}
       @headers = {}
       @schema = nil
-      @on = {
-        new_message: nil,
-        end_message: nil,
-        tool_call: nil,
-        tool_result: nil
-      }
+      @on = CallbackFanout.new
     end
 
     def ask(message = nil, with: nil, &)

spec/fixtures/vcr_cassettes/activerecord_actsas_event_callbacks_allows_chaining_callbacks_on_to_llm_without_losing_persistence.yml

@@ -529,6 +529,20 @@ def uploaded_file(path, type)
       expect(chat.messages.count).to eq(2) # Persistence still works
     end
 
+    it 'allows chaining callbacks on to_llm without losing persistence' do
+      chat = Chat.create!(model: model)
+      llm_chat = chat.to_llm
+
+      user_callback_called = false
+      # Directly attach callback to the underlying Chat object
+      llm_chat.on_new_message { user_callback_called = true }
+
+      chat.ask('Hello')
+
+      expect(user_callback_called).to be true
+      expect(chat.messages.count).to eq(2) # Persistence still works
+    end
+
     it 'calls on_tool_call and on_tool_result callbacks' do
       tool_call_received = nil
       tool_result_received = nil