robot_lab 0.0.8 → 0.0.11

data/lib/robot_lab/robot/bus_messaging.rb

@@ -5,21 +5,16 @@ module RobotLab
     # Inter-robot communication via TypedBus.
     #
     # Expects the including class to provide:
-    #   @bus, @message_counter, @outbox, @message_handler,
-    #   @bus_subscriber_id, @bus_processing, @bus_queue, @name
-    #   and the `run` instance method
+    #   @bus, @bus_poller, @bus_poller_group, @message_counter,
+    #   @outbox, @message_handler, @bus_subscriber_id, @name
+    #   and the `run` instance method.
     #
-    # == Processing Guard
+    # == Delivery Serialization
     #
-    # TypedBus delivers messages in concurrent Async fibers. When a robot's
-    # +run()+ yields during HTTP I/O, the Async scheduler can switch to
-    # another fiber delivering a new bus message to the same robot. This
-    # would interleave user messages between +tool_use+ / +tool_result+
-    # pairs in +@chat+, corrupting Anthropic API message ordering.
-    #
-    # The processing guard serializes delivery handling: deliveries that
-    # arrive while the robot is already processing are queued and drained
-    # sequentially after the current one completes.
+    # TypedBus delivers messages in concurrent Async fibers. Robots
+    # enqueue deliveries into a BusPoller rather than handling them
+    # inline. The BusPoller drains each group's queue sequentially on
+    # a dedicated OS thread, so robot.run() calls never interleave.
     #
     module BusMessaging
       # Send a message to another robot via the bus.
@@ -84,19 +79,6 @@ module RobotLab
       # @param options [Hash] additional options passed to RobotLab.build
       # @return [Robot] the newly created robot
       #
-      # @example Spawn from a bus-less robot (bus and name created automatically)
-      #   bot  = RobotLab.build
-      #   bot2 = bot.spawn(system_prompt: "You are helpful.")
-      #
-      # @example Spawn a specialist from a message handler
-      #   on_message do |message|
-      #     specialist = spawn(
-      #       name: "fact_checker",
-      #       system_prompt: "You verify factual claims. Be concise."
-      #     )
-      #     specialist.send_message(to: name.to_sym, content: specialist.run(message.content).last_text_content)
-      #   end
-      #
       def spawn(name: "robot", system_prompt: nil, template: nil, local_tools: [], **options)
         ensure_bus
 
@@ -120,12 +102,6 @@ module RobotLab
       # @param bus [TypedBus::MessageBus, nil] bus to join (creates one if nil)
       # @return [self]
       #
-      # @example Join an existing bus
-      #   bot = RobotLab.build.with_bus(some_bus)
-      #
-      # @example Create a bus on demand
-      #   bot = RobotLab.build.with_bus
-      #
       def with_bus(bus = nil)
         return self if bus && @bus == bus
 
@@ -135,6 +111,22 @@ module RobotLab
         self
       end
 
+      # Assign a shared BusPoller from a Network.
+      #
+      # Stops any private poller this robot auto-created, then adopts
+      # the network's shared poller for the given group.
+      #
+      # @param poller [BusPoller] the network's shared poller
+      # @param group  [Symbol]    poller group for this robot (default: :default)
+      # @return [void]
+      #
+      def assign_bus_poller(poller, group: :default)
+        @private_bus_poller&.stop
+        @private_bus_poller = nil
+        @bus_poller       = poller
+        @bus_poller_group = group
+      end
+
       private
 
       # Create a bus if one doesn't exist and connect this robot to it
@@ -143,46 +135,42 @@ module RobotLab
       end
 
 
-      # Create a typed channel on the bus and subscribe to it
+      # Create a typed channel on the bus and subscribe to it.
+      # Auto-creates a private BusPoller if none has been assigned.
       def setup_bus_channel
+        unless @bus_poller
+          @private_bus_poller = BusPoller.new.start
+          @bus_poller         = @private_bus_poller
+          @bus_poller_group   = :default
+        end
+
         channel_name = @name.to_sym
         @bus.add_channel(channel_name, type: RobotMessage) unless @bus.channel?(channel_name)
-        @bus_subscriber_id = @bus.subscribe(channel_name) { |delivery| handle_incoming_delivery(delivery) }
+        @bus_subscriber_id = @bus.subscribe(channel_name) { |delivery| enqueue_delivery(delivery) }
       end
 
 
-      # Unsubscribe from the bus channel
+      # Unsubscribe from the bus channel and stop the private poller if any.
       def teardown_bus_channel
         channel_name = @name.to_sym
         @bus.unsubscribe(channel_name, @bus_subscriber_id) if @bus_subscriber_id
         @bus_subscriber_id = nil
-      end
 
+        @private_bus_poller&.stop
+        @private_bus_poller = nil
+        @bus_poller         = nil
+        @bus_poller_group   = :default
+      end
 
-      # Dispatch incoming bus delivery to handler.
-      #
-      # Uses a processing guard to serialize delivery handling. When
-      # the robot is already processing a delivery (e.g., inside a
-      # run() call that yields during HTTP I/O), new deliveries are
-      # queued and drained sequentially after the current one completes.
-      #
-      # Auto-ack when the handler takes 1 arg (message only);
-      # manual ack/nack when the handler takes 2 args (delivery, message).
-      def handle_incoming_delivery(delivery)
-        if @bus_processing
-          @bus_queue << delivery
-          return
-        end
 
-        process_delivery(delivery)
-        drain_bus_queue
+      # Enqueue a delivery to the robot's assigned poller.
+      def enqueue_delivery(delivery)
+        @bus_poller.enqueue(robot: self, delivery: delivery, group: @bus_poller_group)
       end
 
 
-      # Process a single delivery (called under the processing guard)
+      # Process a single delivery (called by BusPoller drain thread).
       def process_delivery(delivery)
-        @bus_processing = true
-
         message = delivery.message
 
         # Correlate replies with outbox entries
@@ -205,16 +193,6 @@ module RobotLab
       rescue => e
         delivery.nack! if delivery.pending?
         raise BusError, "Error handling bus message on robot '#{@name}': #{e.message}"
-      ensure
-        @bus_processing = false
-      end
-
-
-      # Drain queued deliveries sequentially
-      def drain_bus_queue
-        while (queued = @bus_queue.shift)
-          process_delivery(queued)
-        end
       end
 
 

data/lib/robot_lab/robot/history_search.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RobotLab
+  class Robot
+    # Semantic search over a robot's conversation history.
+    #
+    # Scores each message in @chat.messages against the query using stemmed
+    # term-frequency cosine similarity (via the +classifier+ gem).  Returns the
+    # top-N messages ranked by relevance.
+    #
+    # Requires the optional 'classifier' gem (~> 2.3).
+    #
+    # @example
+    #   results = robot.search_history("quarterly revenue", limit: 3)
+    #   results.each do |r|
+    #     puts "[#{r.role}] (score #{r.score.round(3)}) #{r.text}"
+    #   end
+    module HistorySearch
+      # Minimum text length (characters) for a message to be considered.
+      MIN_SCORE_LENGTH = 20
+
+      # Value object returned by {#search_history}.
+      HistoryResult = Data.define(:text, :role, :score, :index)
+
+      # Search the robot's conversation history for messages relevant to +query+.
+      #
+      # @param query [String] natural-language search query
+      # @param limit [Integer] maximum number of results to return (default 5)
+      # @return [Array<HistoryResult>] results sorted by score descending
+      # @raise [RobotLab::DependencyError] if the 'classifier' gem is not installed
+      def search_history(query, limit: 5)
+        TextAnalysis.require_classifier!
+
+        query_vec = TextAnalysis.l2_normalize(query.word_hash)
+        return [] if query_vec.empty?
+
+        results = []
+
+        @chat.messages.each_with_index do |msg, idx|
+          text = extract_history_text(msg)
+          next if text.nil? || text.strip.length < MIN_SCORE_LENGTH
+
+          vec   = TextAnalysis.l2_normalize(text.word_hash)
+          score = TextAnalysis.cosine_similarity(query_vec, vec)
+          next if score.zero?
+
+          results << HistoryResult.new(text: text, role: msg.role, score: score, index: idx)
+        end
+
+        results.sort_by { |r| -r.score }.first(limit)
+      end
+
+      private
+
+      # Extract plain text from a message's content field.
+      #
+      # @param msg [Object] a RubyLLM message-like object
+      # @return [String, nil]
+      def extract_history_text(msg)
+        content = msg.content
+        case content
+        when String then content
+        when Array  then content.filter_map { |p| p[:text] || p["text"] }.join(" ")
+        else nil
+        end
+      end
+    end
+  end
+end

data/lib/robot_lab/robot/mcp_management.rb

@@ -26,17 +26,22 @@ module RobotLab
       end
 
 
-      # Ensure MCP clients are initialized for the given server configs
+      # Ensure MCP clients are initialized for the given server configs.
+      # On subsequent calls, retries any servers that previously failed to connect.
       def ensure_mcp_clients(mcp_servers)
         return if mcp_servers.empty?
 
         needed_servers = mcp_servers.map { |s| s.is_a?(Hash) ? s[:name] : s.to_s }.compact
-        return if @mcp_initialized && (@mcp_clients.keys.sort == needed_servers.sort)
 
-        disconnect if @mcp_initialized
+        if @mcp_initialized
+          # Already initialized — retry any servers that are needed but not connected
+          retry_failed_servers(mcp_servers, needed_servers)
+          return
+        end
 
         @mcp_clients = {}
         @mcp_tools = []
+        @failed_mcp_configs = {}
 
         mcp_servers.each do |server_config|
           init_mcp_client(server_config)
@@ -55,8 +60,48 @@ module RobotLab
           @mcp_clients[server_name] = client
           discover_mcp_tools(client, server_name)
         else
+          server_name = extract_server_name(server_config)
+          @failed_mcp_configs[server_name] = server_config
           RobotLab.config.logger.warn(
-            "Robot '#{@name}' failed to connect to MCP server: #{server_config[:name] || server_config}"
+            "Robot '#{@name}' failed to connect to MCP server: #{server_name}"
+          )
+        end
+      rescue StandardError => e
+        server_name = extract_server_name(server_config)
+        @failed_mcp_configs[server_name] = server_config
+        RobotLab.config.logger.warn(
+          "Robot '#{@name}' error connecting to MCP server '#{server_name}': #{e.message}"
+        )
+      end
+
+
+      # Retry connecting to servers that previously failed
+      def retry_failed_servers(mcp_servers, needed_servers)
+        return if @failed_mcp_configs.nil? || @failed_mcp_configs.empty?
+
+        # Only retry servers that are still needed and still failed
+        to_retry = @failed_mcp_configs.select { |name, _| needed_servers.include?(name) }
+        return if to_retry.empty?
+
+        to_retry.each do |name, server_config|
+          RobotLab.config.logger.info(
+            "Robot '#{@name}' retrying MCP server: #{name}"
+          )
+
+          client = MCP::Client.new(server_config)
+          client.connect
+
+          if client.connected?
+            @mcp_clients[name] = client
+            @failed_mcp_configs.delete(name)
+            discover_mcp_tools(client, name)
+            RobotLab.config.logger.info(
+              "Robot '#{@name}' successfully connected to MCP server '#{name}' on retry"
+            )
+          end
+        rescue StandardError => e
+          RobotLab.config.logger.warn(
+            "Robot '#{@name}' retry failed for MCP server '#{name}': #{e.message}"
           )
         end
       end
@@ -83,6 +128,18 @@ module RobotLab
           "Robot '#{@name}' discovered #{tools.size} tools from MCP server '#{server_name}'"
         )
       end
+
+
+      def extract_server_name(server_config)
+        case server_config
+        when Hash
+          server_config[:name] || server_config['name'] || server_config.to_s
+        when MCP::Server
+          server_config.name
+        else
+          server_config.to_s
+        end
+      end
     end
   end
 end