collavre_openclaw 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffa08c6ff97565abd9d9f0c468b5abce5aaa03df463fd529d9fd5f3f08a7aa6d
-  data.tar.gz: 4bb98ed84ea98fb1067f97c9ae9eea9f9b49365357fecf000fb102a70dd09586
+  metadata.gz: ff70659073539f4ad6104e96ed6c9a85f4b639cf30e6bfdb6e56166d1e5cdf1d
+  data.tar.gz: c96bff5a56ef9f74fc011d649a3be81cbba192c3a3fabbac13281d48929d2d11
 SHA512:
-  metadata.gz: e1fe26478d449c92f136e39142c1fde6db0261c171df1e45bd3e7a2e815065d09c00199c0dbdb93b88e39763da9a13a0909e7bb7f66da5c153acd003f653c990
-  data.tar.gz: 74f7c89b22522e2a43f097d064d5e17785ff91fc042a9db39c3350b142c1a059fe5fade168dd77b62b09c458a5fcc359f68d85d28422fb46f90e69a48b91336d
+  metadata.gz: a3ba72b2e7fd8de71f8276858c8b81ef3767203c6769ab456d837bb9b1dc94f78c6a2584308582dcdf439e48c11d098d6d3673aecc0e34dd01775a5f9263334d
+  data.tar.gz: eddfebd33fbce4ffd79eb80b33d7715e46706947973b4c406b7d866ff98902de24e9bd8ddaa7addf91c6fad6d071aed195f0dbd36800e59a3fbc832feb5e10cd

data/app/services/collavre_openclaw/ai_client_extension.rb

@@ -19,7 +19,7 @@ module CollavreOpenclaw
       adapter_class = self.class.adapter_registry[normalized_vendor]
 
       if adapter_class
-        # Use the custom adapter
+        # Use the custom adapter (tools not supported for OpenClaw)
         user = context&.dig(:user)
         adapter = adapter_class.new(
           user: user,
@@ -31,15 +31,14 @@ module CollavreOpenclaw
         error_message = nil
 
         begin
-          response_content = adapter.chat(contents, tools: tools, &block)
+          response_content = adapter.chat(contents, &block)
         rescue StandardError => e
           error_message = e.message
           raise
         ensure
-          # Log the interaction just like AiClient does
           log_interaction(
             messages: Array(contents),
-            tools: tools,
+            tools: [],
             response_content: response_content,
             error_message: error_message,
             input_tokens: nil,

data/app/services/collavre_openclaw/connection_manager.rb

@@ -0,0 +1,192 @@
+module CollavreOpenclaw
+  # Manages WebSocket connections to OpenClaw Gateways.
+  #
+  # Singleton: use ConnectionManager.instance
+  #
+  # Features:
+  # - Lazy connect (creates connection on first use)
+  # - Connection sharing (same gateway_url → same connection)
+  # - Idle timeout (disconnects after inactivity)
+  # - Thread-safe access
+  # - Graceful shutdown
+  #
+  # Multiple AI agents using the same Gateway share a single WebSocket
+  # connection, reducing resource usage and connection overhead.
+  class ConnectionManager
+    include Singleton
+
+    def initialize
+      @connections = {} # gateway_url → WebsocketClient
+      @gateway_users = {} # gateway_url → Set<user_id> (users sharing this gateway)
+      @user_gateways = {} # user_id → gateway_url (reverse lookup)
+      @mutex = Mutex.new
+      @idle_checker = nil
+      @proactive_handler = nil
+      @proactive_message_handler = ProactiveMessageHandler.new
+      setup_default_proactive_handler!
+      start_idle_checker!
+    end
+
+    # Get or create a WebSocket connection for a user.
+    # Users with the same gateway_url share a single connection.
+    #
+    # @param user [User] must respond to #gateway_url and #llm_api_key
+    # @return [WebsocketClient]
+    def connection_for(user)
+      gateway_url = user.gateway_url.to_s.strip
+      if gateway_url.blank?
+        Rails.logger.warn("[CollavreOpenclaw::ConnectionManager] User #{user.id} has blank gateway_url, cannot create connection")
+        return nil
+      end
+
+      @mutex.synchronize do
+        client = @connections[gateway_url]
+
+        if client.nil?
+          client = WebsocketClient.new(user: user)
+          client.on_proactive_message(&@proactive_handler) if @proactive_handler
+          @connections[gateway_url] = client
+          @gateway_users[gateway_url] = Set.new
+        end
+
+        # Track this user as using this gateway
+        @gateway_users[gateway_url].add(user.id)
+        @user_gateways[user.id] = gateway_url
+
+        client
+      end
+    end
+
+    # Disconnect a specific user from their gateway connection.
+    # The connection is only closed if no other users are sharing it.
+    def disconnect(user)
+      @mutex.synchronize do
+        gateway_url = @user_gateways.delete(user.id)
+        return unless gateway_url
+
+        users = @gateway_users[gateway_url]
+        users&.delete(user.id)
+
+        # Only disconnect if no users are sharing this gateway
+        if users.nil? || users.empty?
+          client = @connections.delete(gateway_url)
+          @gateway_users.delete(gateway_url)
+          client&.disconnect!
+        end
+      end
+    end
+
+    # Disconnect all connections (for app shutdown)
+    def disconnect_all
+      @mutex.synchronize do
+        @connections.each_value(&:disconnect!)
+        @connections.clear
+        @gateway_users.clear
+        @user_gateways.clear
+      end
+      stop_idle_checker!
+    end
+
+    # Number of active connections
+    def connected_count
+      @mutex.synchronize do
+        @connections.count { |_, c| c.connected? }
+      end
+    end
+
+    # Status summary
+    def status
+      @mutex.synchronize do
+        states = @connections.values.group_by(&:state)
+        {
+          connected: states[:connected]&.size || 0,
+          connecting: states[:connecting]&.size || 0,
+          reconnecting: states[:reconnecting]&.size || 0,
+          disconnected: states[:disconnected]&.size || 0,
+          total_connections: @connections.size,
+          total_users: @user_gateways.size
+        }
+      end
+    end
+
+    # Register a proactive message handler for all connections.
+    # New connections will also get this handler.
+    def on_proactive_message(&handler)
+      @mutex.synchronize do
+        @proactive_handler = handler
+        @connections.each_value do |client|
+          client.on_proactive_message(&handler)
+        end
+      end
+    end
+
+    # Get the number of users sharing a specific gateway
+    def users_for_gateway(gateway_url)
+      @mutex.synchronize do
+        @gateway_users[gateway_url]&.size || 0
+      end
+    end
+
+    # Check if a user has an active connection
+    def user_connected?(user)
+      @mutex.synchronize do
+        gateway_url = @user_gateways[user.id]
+        return false unless gateway_url
+        @connections[gateway_url]&.connected? || false
+      end
+    end
+
+    private
+
+    # Set up the default proactive message handler that dispatches
+    # unsolicited chat events to CallbackProcessorJob.
+    def setup_default_proactive_handler!
+      handler = @proactive_message_handler
+      on_proactive_message do |user, payload|
+        handler.handle(user, payload)
+      end
+    end
+
+    def start_idle_checker!
+      @idle_checker_stop = false
+      @idle_checker = Thread.new do
+        Thread.current.name = "openclaw-idle-checker"
+        loop do
+          break if @idle_checker_stop
+          sleep 1 # Check stop flag every second
+          @idle_check_counter = (@idle_check_counter || 0) + 1
+          next unless @idle_check_counter >= 60 # Run check every ~60 seconds
+          @idle_check_counter = 0
+          check_idle_connections!
+        rescue => e
+          Rails.logger.error("[CollavreOpenclaw::ConnectionManager] Idle checker error: #{e.message}")
+        end
+      end
+    end
+
+    def stop_idle_checker!
+      @idle_checker_stop = true
+      @idle_checker&.join(5)
+      @idle_checker = nil
+    end
+
+    def check_idle_connections!
+      timeout = CollavreOpenclaw.config.ws_idle_timeout
+
+      @mutex.synchronize do
+        idle_gateways = @connections.each_with_object([]) do |(gateway_url, client), urls|
+          urls << gateway_url if client.connected? && client.idle_seconds > timeout
+        end
+
+        idle_gateways.each do |gateway_url|
+          client = @connections.delete(gateway_url)
+          user_ids = @gateway_users.delete(gateway_url) || []
+          user_ids.each { |uid| @user_gateways.delete(uid) }
+          user_count = user_ids.size
+          Rails.logger.info("[CollavreOpenclaw::ConnectionManager] Disconnecting idle connection for gateway #{gateway_url} (#{user_count} users)")
+          client&.disconnect!
+        end
+      end
+    end
+  end
+end

data/app/services/collavre_openclaw/em_reactor.rb

@@ -0,0 +1,52 @@
+require "eventmachine"
+
+module CollavreOpenclaw
+  # Manages a single EventMachine reactor thread shared by all WebSocket connections.
+  # Thread-safe: multiple Rails threads can schedule work via .next_tick.
+  class EmReactor
+    class << self
+      def ensure_running!
+        @mutex ||= Mutex.new
+        @mutex.synchronize do
+          return if EM.reactor_running?
+
+          @thread = Thread.new do
+            Thread.current.name = "openclaw-em-reactor"
+            EM.run
+          end
+
+          # Wait until the reactor is actually running
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+          until EM.reactor_running?
+            if Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+              raise "EventMachine reactor failed to start within 5 seconds"
+            end
+            sleep 0.01
+          end
+        end
+      end
+
+      def stop!
+        @mutex&.synchronize do
+          return unless EM.reactor_running?
+
+          # Must stop EM from within the reactor thread
+          EM.next_tick { EM.stop }
+          @thread&.join(5)
+          @thread = nil
+        end
+      end
+
+      def running?
+        EM.reactor_running?
+      end
+
+      # Schedule a block to run in the EM reactor thread.
+      # Safe to call from any thread.
+      def next_tick(&block)
+        ensure_running!
+        EM.next_tick(&block)
+      end
+    end
+  end
+end