robot_lab 0.1.0 → 0.2.1

data/lib/robot_lab/ask_user.rb

@@ -65,11 +65,11 @@ module RobotLab
     private
 
     def input_io
-      robot&.respond_to?(:input) && robot.input ? robot.input : $stdin
+      robot.respond_to?(:input) && robot.input ? robot.input : $stdin
     end
 
     def output_io
-      robot&.respond_to?(:output) && robot.output ? robot.output : $stdout
+      robot.respond_to?(:output) && robot.output ? robot.output : $stdout
     end
   end
 end

data/lib/robot_lab/bus_poller.rb

@@ -115,7 +115,16 @@ module RobotLab
     # Process one delivery, then drain any queued deliveries for the robot.
     def process_and_drain(robot, delivery)
       robot.send(:process_delivery, delivery)
+      drain_queued_deliveries(robot)
+    rescue BusError => e
+      release_robot(robot)
+      RobotLab.config.logger.warn("BusPoller: delivery error: #{e.message}")
+    rescue => e
+      release_robot(robot)
+      RobotLab.config.logger.warn("BusPoller: unexpected error: #{e.message}")
+    end
 
+    def drain_queued_deliveries(robot)
       loop do
         next_delivery = @mutex.synchronize do
           name  = robot.name
@@ -138,12 +147,10 @@ module RobotLab
           RobotLab.config.logger.warn("BusPoller: delivery error: #{e.message}")
         end
       end
-    rescue BusError => e
-      @mutex.synchronize { @robot_busy[robot.name] = false }
-      RobotLab.config.logger.warn("BusPoller: delivery error: #{e.message}")
-    rescue => e
+    end
+
+    def release_robot(robot)
       @mutex.synchronize { @robot_busy[robot.name] = false }
-      RobotLab.config.logger.warn("BusPoller: unexpected error: #{e.message}")
     end
   end
 end

data/lib/robot_lab/config.rb

@@ -43,7 +43,6 @@ module RobotLab
       @logger ||= default_logger
     end
 
-
     # Apply RubyLLM configuration after loading.
     #
     # This method should be called after initialization to configure
@@ -56,7 +55,6 @@ module RobotLab
       apply_prompt_manager!
     end
 
-
     # Apply all RubyLLM settings from the ruby_llm configuration section.
     #
     # @return [void]
@@ -100,7 +98,6 @@ module RobotLab
       set_if_present(c, :vertexai_location, :vertexai_location, 'GOOGLE_CLOUD_LOCATION')
     end
 
-
     def apply_provider_endpoints(c)
       c.openai_api_base = ruby_llm.openai_api_base if ruby_llm.openai_api_base
       c.gemini_api_base = ruby_llm.gemini_api_base if ruby_llm.gemini_api_base
@@ -109,14 +106,12 @@ module RobotLab
       c.xai_api_base = ruby_llm.xai_api_base if ruby_llm.xai_api_base
     end
 
-
     def apply_openai_options(c)
       c.openai_organization_id = ruby_llm.openai_organization_id if ruby_llm.openai_organization_id
       c.openai_project_id = ruby_llm.openai_project_id if ruby_llm.openai_project_id
       c.openai_use_system_role = ruby_llm.openai_use_system_role unless ruby_llm.openai_use_system_role.nil?
     end
 
-
     def apply_default_models(c)
       c.default_model = ruby_llm.default_model if ruby_llm.default_model
       c.default_embedding_model = ruby_llm.default_embedding_model if ruby_llm.default_embedding_model
@@ -124,7 +119,6 @@ module RobotLab
       c.default_moderation_model = ruby_llm.default_moderation_model if ruby_llm.default_moderation_model
     end
 
-
     def apply_connection_settings(c)
       c.request_timeout = ruby_llm.request_timeout if ruby_llm.request_timeout
       c.max_retries = ruby_llm.max_retries if ruby_llm.max_retries
@@ -134,14 +128,12 @@ module RobotLab
       c.http_proxy = ruby_llm.http_proxy if ruby_llm.http_proxy
     end
 
-
     def apply_logging_options(c)
       c.log_file = ruby_llm.log_file if ruby_llm.log_file
       c.log_level = ruby_llm.log_level if ruby_llm.log_level
       c.log_stream_debug = ruby_llm.log_stream_debug unless ruby_llm.log_stream_debug.nil?
     end
 
-
     def apply_prompt_manager!
       path = resolved_template_path
       return unless path
@@ -151,15 +143,13 @@ module RobotLab
       end
     end
 
-
     # Set a RubyLLM config attribute from config value or standard env var.
     # Only sets when a non-nil value is found, to avoid overwriting defaults.
     def set_if_present(c, setter, config_key, env_var)
-      value = ruby_llm.public_send(config_key) || ENV[env_var]
+      value = ruby_llm.public_send(config_key) || ENV.fetch(env_var, nil)
       c.public_send(:"#{setter}=", value) if value
     end
 
-
     def resolved_template_path
       return template_path if template_path
 
@@ -170,7 +160,6 @@ module RobotLab
       end
     end
 
-
     def default_logger
       if defined?(Rails) && Rails.respond_to?(:logger)
         Rails.logger

data/lib/robot_lab/delegation_future.rb

@@ -70,7 +70,7 @@ module RobotLab
         @result
       end
     end
-    alias_method :wait, :value
+    alias wait value
 
     # @api private — called by Robot#delegate from the worker thread
     def resolve!(result)

data/lib/robot_lab/doom_loop_detector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RobotLab
+  # Detects and interrupts tool-call doom loops inside the LLM agent loop.
+  #
+  # A doom loop occurs when the LLM repeatedly calls the same tool(s) in a
+  # cycle — either identical consecutive calls (A, A, A) or a repeating
+  # multi-step pattern (A, B, C, A, B, C, A, B, C).
+  #
+  # When a doom loop is detected the warning is embedded in the tool result
+  # so the LLM sees it in its next context window and can self-correct.
+  #
+  # @example Basic usage
+  #   detector = DoomLoopDetector.new(threshold: 3)
+  #   detector.track("search")
+  #   detector.track("search")
+  #   detector.track("search")
+  #   detector.doom_loop?  # => true
+  #   detector.warning_message
+  #   # => "Tool 'search' has been called 3 times consecutively..."
+  class DoomLoopDetector
+    DEFAULT_THRESHOLD = 3
+    MAX_PERIOD = 10
+
+    attr_reader :sequence
+
+    def initialize(threshold: DEFAULT_THRESHOLD)
+      @threshold = threshold
+      @sequence  = []
+    end
+
+    def track(tool_name)
+      @sequence << tool_name.to_s
+    end
+
+    def doom_loop?
+      seq = @sequence
+      return false if seq.length < @threshold
+
+      # Consecutive identical calls: A, A, A
+      tail = seq.last(@threshold)
+      return true if tail.uniq.length == 1
+
+      # Cyclic multi-step patterns: A,B,C, A,B,C, A,B,C
+      max_period = [MAX_PERIOD, seq.length / @threshold].min
+      (2..max_period).each do |period|
+        window = @threshold * period
+        next if seq.length < window
+
+        chunk = seq.last(window)
+        pattern = chunk.first(period)
+        return true if chunk == pattern * @threshold
+      end
+
+      false
+    end
+
+    def reset
+      @sequence = []
+    end
+
+    def warning_message
+      seq = @sequence
+      return "" if seq.empty?
+
+      period = detect_period(seq)
+      if period == 1
+        tool = seq.last
+        "Tool '#{tool}' has been called #{@threshold}+ times consecutively with " \
+          "no progress. You appear to be stuck in a loop. Try a fundamentally " \
+          "different approach, use a different tool, or ask for clarification."
+      else
+        pattern = seq.last(period).join(" → ")
+        "Tool call pattern [#{pattern}] has repeated #{@threshold}+ times. " \
+          "You appear to be stuck in a loop. Try a fundamentally different " \
+          "approach, use a different tool, or ask for clarification."
+      end
+    end
+
+    private
+
+    def detect_period(seq)
+      return 1 if seq.last(@threshold).uniq.length == 1
+
+      max_period = [MAX_PERIOD, seq.length / @threshold].min
+      (2..max_period).each do |period|
+        window = @threshold * period
+        next if seq.length < window
+
+        chunk = seq.last(window)
+        pattern = chunk.first(period)
+        return period if chunk == pattern * @threshold
+      end
+
+      1
+    end
+  end
+end

data/lib/robot_lab/history_compressor.rb

@@ -124,13 +124,11 @@ module RobotLab
 
       if score >= @keep_threshold
         :keep
-      elsif score < @drop_threshold
+      elsif score < @drop_threshold || !@summarizer
         :drop
-      elsif @summarizer
+      else
         summary = @summarizer.call(text).to_s.strip
         summary.empty? ? :drop : summary
-      else
-        :drop
       end
     end
 
@@ -141,10 +139,7 @@ module RobotLab
       @messages.each_with_index do |msg, idx|
         action = actions[idx]
 
-        if action.nil?
-          # Pinned or recent: always include
-          result << msg
-        elsif action == :keep
+        if action.nil? || action == :keep
           result << msg
         elsif action == :drop
           # Omit entirely
@@ -166,7 +161,7 @@ module RobotLab
       role = msg.role
 
       return true if role == :system
-      return true if role == :tool || role == :tool_result
+      return true if %i[tool tool_result].include?(role)
 
       # Assistant tool-call dispatcher: content is nil or blank
       if role == :assistant
@@ -185,7 +180,6 @@ module RobotLab
       case content
       when String then content
       when Array  then content.filter_map { |p| p[:text] || p["text"] }.join(" ")
-      else nil
       end
     end
 

data/lib/robot_lab/mcp/client.rb

@@ -141,8 +141,7 @@ module RobotLab
       #
       def get_prompt(name, arguments = {})
         ensure_connected!
-        response = request(method: "prompts/get", params: { name: name, arguments: arguments })
-        response
+        request(method: "prompts/get", params: { name: name, arguments: arguments })
       end
 
       # Checks if the client is connected to the server.

data/lib/robot_lab/mcp/connection_poller.rb

@@ -145,15 +145,15 @@ module RobotLab
         loop do
           ios = @mutex.synchronize { @clients.keys.reject(&:closed?) }
 
-          unless ios.empty?
+          if ios.empty?
+            sleep POLL_INTERVAL
+          else
             begin
               ready, = IO.select(ios, nil, nil, POLL_INTERVAL)
               dispatch(ready) if ready
             rescue Errno::EBADF
               # A pipe was closed between the reject and IO.select — harmless, loop again
             end
-          else
-            sleep POLL_INTERVAL
           end
 
           break unless @mutex.synchronize { @running }

data/lib/robot_lab/mcp/server.rb

@@ -99,7 +99,7 @@ module RobotLab
 
         seconds = value.to_f
         # If the caller passed milliseconds (>= 1000), convert to seconds
-        seconds = seconds / 1000.0 if seconds >= 1000
+        seconds /= 1000.0 if seconds >= 1000
         [seconds, 1].max
       end
     end

data/lib/robot_lab/mcp/server_discovery.rb

@@ -76,8 +76,6 @@ module RobotLab
         from
       end
 
-      private
-
       # @param servers [Array<Hash, MCP::Server>]
       def self.any_descriptions?(servers)
         servers.any? { |s| !description_for(s).empty? }

data/lib/robot_lab/memory.rb

@@ -89,7 +89,8 @@ module RobotLab
     #
     # @example Network-owned memory
     #   Memory.new(network_name: "support_pipeline")
-    def initialize(data: {}, results: [], messages: [], session_id: nil, backend: :auto, enable_cache: true, network_name: nil)
+    def initialize(data: {}, results: [], messages: [], session_id: nil, backend: :auto, enable_cache: true,
+                   network_name: nil)
       @backend = select_backend(backend)
       @mutex = Mutex.new
       @enable_cache = enable_cache
@@ -104,7 +105,7 @@ module RobotLab
       set_internal(:cache, @enable_cache ? RubyLLM::SemanticCache : nil)
 
       # Data proxy for method-style access
-      @data_proxy = nil
+      @data = nil
 
       # Reactive infrastructure
       @subscriptions = Hash.new { |h, k| h[k] = [] }
@@ -149,7 +150,7 @@ module RobotLab
       # Reserved keys have special handling (no notifications)
       case key
       when :data
-        @data_proxy = nil  # Reset proxy
+        @data = nil  # Reset proxy
         set_internal(:data, value.is_a?(Hash) ? value.transform_keys(&:to_sym) : value)
       when :results
         set_internal(:results, Array(value))
@@ -164,8 +165,6 @@ module RobotLab
         # Non-reserved keys use reactive set
         set(key, value)
       end
-
-      value
     end
 
     # Access runtime data through StateProxy
@@ -173,7 +172,7 @@ module RobotLab
     # @return [StateProxy] proxy for method-style data access
     #
     def data
-      @data_proxy ||= StateProxy.new(get_internal(:data) || {})
+      @data ||= StateProxy.new(get_internal(:data) || {})
     end
 
     # Get copy of results (immutable access)
@@ -207,7 +206,6 @@ module RobotLab
     #
     def session_id=(id)
       set_internal(:session_id, id)
-      self
     end
 
     # Get the semantic cache module
@@ -450,16 +448,14 @@ module RobotLab
     #   hits.each { |h| puts "#{h[:key]} (#{h[:score].round(3)}): #{h[:text][0..80]}" }
     #
     def search_documents(query, limit: 5)
-      return [] unless @document_store
-
-      @document_store.search(query, limit: limit)
+      document_store.search(query, limit: limit)
     end
 
     # Keys of all documents stored in the embedded document store.
     #
     # @return [Array<Symbol>]
     def document_keys
-      @document_store&.keys || []
+      document_store.keys
     end
 
     # Remove a document from the store.
@@ -467,7 +463,7 @@ module RobotLab
     # @param key [Symbol, String]
     # @return [self]
     def delete_document(key)
-      @document_store&.delete(key)
+      document_store.delete(key)
       self
     end
 
@@ -590,7 +586,7 @@ module RobotLab
         @backend[:session_id] = nil
         @backend[:cache] = cached  # Restore cache instance
       end
-      @data_proxy = nil
+      @data = nil
       self
     end
 
@@ -641,7 +637,7 @@ module RobotLab
         results: results.map(&:export),
         messages: messages.map(&:to_h),
         session_id: session_id,
-        custom: keys.each_with_object({}) { |k, h| h[k] = self[k] }
+        custom: keys.to_h { |k| [k, self[k]] }
       }.compact
     end
 
@@ -650,8 +646,8 @@ module RobotLab
     # @param args [Array] arguments passed to to_json
     # @return [String]
     #
-    def to_json(*args)
-      to_h.to_json(*args)
+    def to_json(*)
+      to_h.to_json(*)
     end
 
     # Reconstruct memory from hash
@@ -687,7 +683,12 @@ module RobotLab
     private
 
     def document_store
-      @document_store ||= DocumentStore.new
+      unless RobotLab.extension_loaded?(:document_store)
+        raise RobotLab::DependencyError,
+              "document storage requires the robot_lab-document_store gem. " \
+              "Add `gem 'robot_lab-document_store'` to your Gemfile."
+      end
+      @document_store ||= RobotLab::DocumentStore.new
     end
 
     def create_semantic_cache
@@ -696,11 +697,9 @@ module RobotLab
 
     def select_backend(preference)
       case preference
-      when :redis
-        create_redis_backend || create_hash_backend
       when :hash
         create_hash_backend
-      else # :auto
+      else # :redis, :auto
         create_redis_backend || create_hash_backend
       end
     end
@@ -722,7 +721,7 @@ module RobotLab
 
       # Check if Redis is configured in RobotLab
       redis_config = RobotLab.config.respond_to?(:redis) ? RobotLab.config.redis : nil
-      redis_config || ENV["REDIS_URL"]
+      redis_config || ENV.fetch("REDIS_URL", nil)
     end
 
     def get_internal(key)
@@ -877,8 +876,15 @@ module RobotLab
       end
     ensure
       reschedule = @notification_queue_mutex.synchronize do
-        @drainer_scheduled = false
-        !@notification_queue.empty?
+        if @notification_queue.empty?
+          @drainer_scheduled = false
+          false
+        else
+          # Keep the flag set so concurrent writers don't also spawn a drainer.
+          # Only we will reschedule — no double-schedule race.
+          @drainer_scheduled = true
+          true
+        end
       end
       dispatch_async { drain_notification_queue } if reschedule
     end
@@ -890,9 +896,9 @@ module RobotLab
     def pattern_to_regex(pattern)
       # Convert glob pattern to regex
       regex_str = pattern
-        .gsub(".", "\\.")
-        .gsub("*", ".*")
-        .gsub("?", ".")
+                  .gsub(".", "\\.")
+                  .gsub("*", ".*")
+                  .gsub("?", ".")
 
       Regexp.new("\\A#{regex_str}\\z")
     end
@@ -917,7 +923,6 @@ module RobotLab
     def []=(key, value)
       serialized = value.is_a?(String) ? value : value.to_json
       @redis.set("#{@namespace}:#{key}", serialized)
-      value
     end
 
     def key?(key)

data/lib/robot_lab/memory_change.rb

@@ -98,8 +98,8 @@ module RobotLab
     # @param args [Array] arguments passed to to_json
     # @return [String]
     #
-    def to_json(*args)
-      to_h.to_json(*args)
+    def to_json(*)
+      to_h.to_json(*)
     end
 
     # Reconstruct from hash.

data/lib/robot_lab/message.rb

@@ -79,8 +79,8 @@ module RobotLab
     #
     # @param args [Array] arguments passed to to_json
     # @return [String] JSON representation of the message
-    def to_json(*args)
-      to_h.to_json(*args)
+    def to_json(*)
+      to_h.to_json(*)
     end
 
     # Creates a Message instance from a hash.
@@ -200,8 +200,8 @@ module RobotLab
     #
     # @param args [Array] arguments passed to to_json
     # @return [String] JSON representation
-    def to_json(*args)
-      to_h.to_json(*args)
+    def to_json(*)
+      to_h.to_json(*)
     end
 
     # Creates a ToolMessage from a hash.

data/lib/robot_lab/network.rb

@@ -86,7 +86,7 @@ module RobotLab
     #     task :billing, billing_robot, context: { dept: "billing" }, depends_on: :optional
     #   end
     #
-    def initialize(name:, concurrency: :auto, memory: nil, config: nil, parallel_mode: :async, &block)
+    def initialize(name:, concurrency: :auto, memory: nil, config: nil, parallel_mode: :async, &)
       @name = name.to_s
       @robots = {}
       @tasks = {}
@@ -97,7 +97,7 @@ module RobotLab
       @broadcast_handlers = []
       @bus_poller = BusPoller.new.start
 
-      instance_eval(&block) if block_given?
+      instance_eval(&) if block_given?
     end
 
     # Add a robot as a pipeline task with optional per-task configuration
@@ -123,7 +123,8 @@ module RobotLab
     # @example Task with dependencies
     #   task :writer, writer_robot, depends_on: [:analyst]
     #
-    def task(name, robot, context: {}, mcp: :none, tools: :none, memory: nil, config: nil, depends_on: :none, poller_group: :default)
+    def task(name, robot, context: {}, mcp: :none, tools: :none, memory: nil, config: nil, depends_on: :none,
+             poller_group: :default)
       task_wrapper = Task.new(
         name: name,
         robot: robot,
@@ -158,8 +159,8 @@ module RobotLab
     #   end
     #   task :process, processor, depends_on: :fetch_data
     #
-    def parallel(name = nil, depends_on: :none, &block)
-      @pipeline.parallel(name, depends_on: depends_on, &block)
+    def parallel(name = nil, depends_on: :none, &)
+      @pipeline.parallel(name, depends_on: depends_on, &)
       self
     end
 
@@ -351,6 +352,11 @@ module RobotLab
     private
 
     def run_with_ractor_scheduler(run_context)
+      unless RobotLab.extension_loaded?(:ractor)
+        raise RobotLab::DependencyError,
+              "parallel_mode: :ractor requires the robot_lab-ractor gem. " \
+              "Add `gem 'robot_lab-ractor'` to your Gemfile."
+      end
       message   = run_context[:message].to_s
       dep_graph = @pipeline.step_dependencies  # { task_sym => [dep_sym, ...] }
 
@@ -373,6 +379,5 @@ module RobotLab
       scheduler.shutdown
       results
     end
-
   end
 end