robot_lab 0.2.8 → 0.3.1

data/lib/robot_lab/robot.rb

@@ -7,6 +7,7 @@ require_relative 'robot/history_search'
 require_relative 'robot/agent_skill_matching'
 require_relative 'robot/budget'
 require_relative 'robot/hooking'
+require_relative 'robot/result_building'
 
 module RobotLab
   # LLM-powered robot built on RubyLLM::Agent
@@ -54,6 +55,7 @@ module RobotLab
     include Robot::HistorySearch
     include Robot::Budget
     include Robot::Hooking
+    include Robot::ResultBuilding
     include Runnable
     prepend Robot::AgentSkillMatching
 
@@ -367,9 +369,7 @@ module RobotLab
     # access to conversation state.
     #
     # @return [RubyLLM::Chat]
-    def chat
-      @chat
-    end
+    attr_reader :chat
 
     # Return the conversation messages from the underlying chat.
     #
@@ -386,10 +386,10 @@ module RobotLab
     def clear_messages(keep_system: true)
       if keep_system
         system_msg = @chat.messages.find { |m| m.role == :system }
-        @chat.reset_messages!
+        @chat.messages = []
         @chat.add_message(system_msg) if system_msg
       else
-        @chat.reset_messages!
+        @chat.messages = []
       end
       self
     end
@@ -399,8 +399,8 @@ module RobotLab
     # @param messages [Array<RubyLLM::Message>] the messages to restore
     # @return [self]
     def replace_messages(messages)
-      @chat.reset_messages!
-      messages.each { |m| @chat.add_message(m) }
+      @chat.messages = []
+      messages.each { |m| @chat.add_message(coerce_replacement_message(m)) }
       self
     end
 
@@ -665,6 +665,8 @@ module RobotLab
       @learnings           = []
       @hooks               = HookRegistry.new
       @budget_ledger       = build_budget_ledger
+      @circuit_breaker_armed      = false
+      @circuit_breaker_call_count = 0
     end
 
     def initialize_memory
@@ -716,20 +718,33 @@ module RobotLab
 
     def apply_chat_params
       @chat.with_temperature(@config.temperature) if @config.temperature
+      @chat.with_max_output_tokens(@config.max_tokens) if @config.max_tokens
 
+      # ruby_llm 2.0 has no with_params; provider-specific sampling knobs are
+      # merged into the request payload via with_provider_options instead.
+      # with_provider_options replaces prior options, so merge with whatever
+      # the chat already carries (e.g. from template front matter).
       extra_params = {
         top_p: @config.top_p, top_k: @config.top_k,
-        max_tokens: @config.max_tokens,
         presence_penalty: @config.presence_penalty,
         frequency_penalty: @config.frequency_penalty,
         stop: @config.stop
       }.compact
-      @chat.with_params(**extra_params) if extra_params.any?
+      @chat.with_provider_options(@chat.provider_options.to_h.merge(extra_params)) if extra_params.any?
     end
 
+    # ruby_llm 2.0 callbacks (before_tool_call/after_tool_result) are additive
+    # and cannot be removed, so register a single dispatcher per chat that
+    # consults the robot's current state. The per-run circuit breaker arms and
+    # disarms a flag instead of swapping callbacks.
     def register_chat_callbacks
-      @chat.on_tool_call(&@on_tool_call)     if @on_tool_call
-      @chat.on_tool_result(&@on_tool_result) if @on_tool_result
+      @chat.before_tool_call do |tool_call|
+        enforce_circuit_breaker! if @circuit_breaker_armed
+        @on_tool_call&.call(tool_call)
+      end
+      @chat.after_tool_result do |result|
+        @on_tool_result&.call(result)
+      end
       setup_bus_channel if @bus
     end
 
@@ -761,6 +776,7 @@ module RobotLab
       end
     end
 
+    # :reek:TooManyStatements -- resolve/discover/connect/filter/attach is one linear per-turn tool pipeline.
     def prepare_tools(message:, mcp:, tools:, network:, network_config:)
       resolved_mcp   = resolve_mcp_hierarchy(mcp, network: network, network_config: network_config)
       resolved_tools = resolve_tools_hierarchy(tools, network: network, network_config: network_config)
@@ -779,12 +795,16 @@ module RobotLab
       # runtime value before resolution to honor the zero-tools intent.
       filtered = explicit_none_tools?(tools) ? [] : cap_tools(filtered_tools(resolved_tools))
 
-      # replace: true so the chat holds EXACTLY this turn's resolved+capped set.
-      # RubyLLM's with_tools appends by default; on a persistent chat that lets
-      # tools accumulate across turns, so a capped per-turn addition could still
-      # push the chat's total past the provider limit. An explicit none clears
-      # the chat's tools to zero (with_tools(replace: true) with no tools).
-      @chat.with_tools(*filtered, replace: true) if filtered.any? || explicit_none_tools?(tools)
+      # Clear-then-add so the chat holds EXACTLY this turn's resolved+capped
+      # set. RubyLLM's with_tools appends; on a persistent chat that lets tools
+      # accumulate across turns, so a capped per-turn addition could still push
+      # the chat's total past the provider limit. with_tools(nil) is ruby_llm
+      # 2.0's "clear the tool set"; an explicit none stops there, sending zero
+      # tools this turn.
+      return unless filtered.any? || explicit_none_tools?(tools)
+
+      @chat.with_tools(nil)
+      @chat.with_tools(*filtered) if filtered.any?
     end
 
     # True when the runtime tools value explicitly requests zero tools — `:none`
@@ -902,85 +922,6 @@ module RobotLab
       merged
     end
 
-    # :reek:TooManyStatements :reek:FeatureEnvy -- adapting a provider response's many optional fields into
-    #   a RobotResult is inherently response-centric.
-    def build_result(response, _memory)
-      text = result_text(response)
-      output = text ? [TextMessage.new(role: 'assistant', content: text)] : []
-
-      tool_calls = response.respond_to?(:tool_calls) ? (response.tool_calls || []) : []
-
-      # Extract token usage from the response
-      input_toks = output_toks = 0
-      if response.respond_to?(:tokens) && (tokens = response.tokens)
-        input_toks = tokens.input.to_i
-        output_toks = tokens.output.to_i
-      elsif response.respond_to?(:input_tokens)
-        input_toks = response.input_tokens.to_i
-        output_toks = response.respond_to?(:output_tokens) ? response.output_tokens.to_i : 0
-      end
-
-      @total_input_tokens += input_toks
-      @total_output_tokens += output_toks
-
-      RobotResult.new(
-        robot_name: @name,
-        output: output,
-        tool_calls: normalize_tool_calls(tool_calls),
-        stop_reason: response.respond_to?(:stop_reason) ? response.stop_reason : nil,
-        raw: response,
-        input_tokens: input_toks,
-        output_tokens: output_toks
-      )
-    end
-
-    # Text for the result's output. Prefers the final response's content, then
-    # falls back in order to: (1) thinking text for models that route all output
-    # through reasoning_content (e.g. qwen3 on Ollama), (2) the most recent
-    # assistant text within the current turn for models that end on a tool call
-    # with no trailing text.
-    #
-    # The chat-history fallback is scoped to messages AFTER the last user message
-    # (the current turn) to prevent a previous turn's response from being returned
-    # when a thinking-mode model emits nothing in response.content.
-    # :reek:TooManyStatements :reek:FeatureEnvy -- documented fallback chain over the response's optional content/thinking/history fields.
-    def result_text(response)
-      content = response.content if response.respond_to?(:content)
-      return content if content && !content.to_s.empty?
-
-      # Ollama routes qwen3's reasoning to reasoning_content, which ruby_llm
-      # surfaces as response.thinking (a RubyLLM::Thinking object). When content
-      # is nil and thinking is present, the thinking IS the response for that turn.
-      if response.respond_to?(:thinking) && (thinking = response.thinking)
-        thinking_text = thinking.respond_to?(:text) ? thinking.text.to_s : thinking.to_s
-        return thinking_text unless thinking_text.empty?
-      end
-
-      return nil unless @chat.respond_to?(:messages)
-
-      messages = @chat.messages
-      last_user_idx = messages.rindex { |m| m.role == :user } || -1
-      current_turn = messages[(last_user_idx + 1)..]
-
-      last = current_turn.rfind { |m| m.role == :assistant && m.content && !m.content.to_s.empty? }
-      last&.content
-    end
-
-    def normalize_tool_calls(tool_calls)
-      return [] unless tool_calls
-
-      tool_calls.map do |tc|
-        if tc.is_a?(Hash)
-          ToolResultMessage.new(
-            tool: tc,
-            content: tc[:result] || tc['result']
-          )
-        else
-          tc
-        end
-      end
-    end
-
     # Merge the stored on_content callback with a runtime streaming block.
     # If both exist, both fire (stored first, then runtime block).
     #
@@ -1124,29 +1065,5 @@ module RobotLab
         RobotLab.config.logger.warn("[#{@name}] auto_compact: #{e.message}; skipping compaction")
       end
     end
-
-    # Install a per-run circuit breaker on the chat's on_tool_call hook.
-    # Raises ToolLoopError if tool calls exceed @config.max_tool_rounds.
-    # Stores the previous callback so restore_tool_call_callback can undo it.
-    def install_circuit_breaker
-      @circuit_breaker_call_count = 0
-      max = @config.max_tool_rounds
-      original = @on_tool_call
-
-      @chat.on_tool_call do |tool_call|
-        @circuit_breaker_call_count += 1
-        if @circuit_breaker_call_count > max
-          raise ToolLoopError,
-                "Circuit breaker triggered: #{@circuit_breaker_call_count} tool calls exceeded " \
-                "max_tool_rounds (#{max})"
-        end
-        original&.call(tool_call)
-      end
-    end
-
-    # Restore the original on_tool_call callback after a circuit-breaker run.
-    def restore_tool_call_callback
-      @chat.on_tool_call(&@on_tool_call)
-    end
   end
 end

data/lib/robot_lab/run_config.rb

@@ -12,20 +12,20 @@ module RobotLab
   # config's non-nil values win over the less-specific config.
   #
   # @example Keyword construction
-  #   config = RunConfig.new(model: "claude-sonnet-4", temperature: 0.7)
+  #   config = RunConfig.new(model: "claude-sonnet-4-6", temperature: 0.7)
   #
   # @example Block DSL
   #   config = RunConfig.new do |c|
-  #     c.model "claude-sonnet-4"
+  #     c.model "claude-sonnet-4-6"
   #     c.temperature 0.7
   #   end
   #
   # @example Merge (more-specific wins)
-  #   network_config = RunConfig.new(model: "claude-sonnet-4", temperature: 0.5)
+  #   network_config = RunConfig.new(model: "claude-sonnet-4-6", temperature: 0.5)
   #   robot_config   = RunConfig.new(temperature: 0.9)
   #   effective       = network_config.merge(robot_config)
   #   effective.temperature  #=> 0.9
-  #   effective.model        #=> "claude-sonnet-4"
+  #   effective.model        #=> "claude-sonnet-4-6"
   #
   # :reek:RepeatedConditional -- `if value` guards in independent field loops; each skips unset fields.
   class RunConfig
@@ -106,6 +106,10 @@ module RobotLab
       self.class.new(**merged)
     end
 
+    # Fields that ruby_llm 2.0 accepts only through with_provider_options
+    # (merged into the request payload in the provider's own vocabulary).
+    PROVIDER_OPTION_FIELDS = %i[top_p top_k presence_penalty frequency_penalty stop].freeze
+
     # Applies LLM fields to a chat object via its with_* methods.
     #
     # +provider+/+assume_model_exists+ are threaded through to +with_model+
@@ -117,27 +121,26 @@ module RobotLab
     # raises ModelNotFoundError for any local-provider model (Ollama, etc.)
     # not in RubyLLM's bundled registry.
     #
+    # ruby_llm 2.0 mapping: +max_tokens+ applies via with_max_output_tokens,
+    # and the sampling knobs (top_p, top_k, penalties, stop) go through
+    # with_provider_options, merged with any options the chat already has.
+    #
     # @param chat [Object] a RubyLLM::Chat (or similar) that responds to with_model, with_temperature, etc.
     # @param provider [String, Symbol, nil] passed through to chat.with_model's provider: kwarg
-    # @param assume_model_exists [Boolean] passed through to chat.with_model's assume_exists: kwarg
+    # @param assume_model_exists [Boolean] passed through to chat.with_model's assume_model_exists: kwarg
     # :reek:BooleanParameter -- assume_model_exists is a pass-through to RubyLLM's with_model kwarg.
     # :reek:FeatureEnvy -- configuring the chat object handed in is exactly what apply_to is for.
+    # :reek:TooManyStatements -- one guarded application per LLM field group.
     def apply_to(chat, provider: nil, assume_model_exists: false)
-      LLM_FIELDS.each do |field|
-        value = @fields[field]
-        next unless value
-
-        if field == :model && provider
-          # Only take the provider-aware path when a provider was actually
-          # given -- preserves the original single-arg call (and thus
-          # compatibility with any chat-like object exposing only
-          # `with_model(value)`) for the common case.
-          chat.with_model(value, provider:, assume_exists: assume_model_exists) if chat.respond_to?(:with_model)
-        else
-          method = :"with_#{field}"
-          chat.public_send(method, value) if chat.respond_to?(method)
-        end
-      end
+      apply_model_to(chat, provider: provider, assume_model_exists: assume_model_exists)
+
+      temperature = @fields[:temperature]
+      chat.with_temperature(temperature) if temperature && chat.respond_to?(:with_temperature)
+
+      max_tokens = @fields[:max_tokens]
+      chat.with_max_output_tokens(max_tokens) if max_tokens && chat.respond_to?(:with_max_output_tokens)
+
+      apply_provider_options_to(chat)
     end
 
     # Build a RunConfig from prompt_manager front matter metadata.
@@ -187,6 +190,35 @@ module RobotLab
 
     private
 
+    # Apply the model field, threading provider/assume_model_exists through
+    # only when a provider was actually given -- preserves the original
+    # single-arg call (and thus compatibility with any chat-like object
+    # exposing only `with_model(value)`) for the common case.
+    # :reek:BooleanParameter -- pass-through to RubyLLM's with_model kwarg.
+    # :reek:FeatureEnvy -- configuring the chat handed in is exactly what apply_to delegates here.
+    def apply_model_to(chat, provider:, assume_model_exists:)
+      model = @fields[:model]
+      return unless model && chat.respond_to?(:with_model)
+
+      if provider
+        chat.with_model(model, provider: provider, assume_model_exists: assume_model_exists)
+      else
+        chat.with_model(model)
+      end
+    end
+
+    # Merge the sampling knobs into the chat's provider options.
+    # with_provider_options replaces prior options wholesale, so merge with
+    # the chat's current set to keep options applied earlier.
+    # :reek:FeatureEnvy -- configuring the chat handed in is exactly what apply_to delegates here.
+    def apply_provider_options_to(chat)
+      options = @fields.slice(*PROVIDER_OPTION_FIELDS)
+      return if options.empty? || !chat.respond_to?(:with_provider_options)
+
+      current = chat.respond_to?(:provider_options) ? chat.provider_options.to_h : {}
+      chat.with_provider_options(current.merge(options))
+    end
+
     # Validates and stores a field value. Nil removes the key.
     def set(field, value)
       field = field.to_sym

data/lib/robot_lab/tool.rb

@@ -9,7 +9,7 @@ module RobotLab
   #
   #   class GetWeather < RobotLab::Tool
   #     description "Get weather for a location"
-  #     param :location, type: "string", desc: "City name"
+  #     parameter :location, type: "string", description: "City name"
   #
   #     def execute(location:)
   #       WeatherService.fetch(location)
@@ -93,10 +93,11 @@ module RobotLab
     #
     # For non-Ractor-safe tools: runs execute directly in the calling thread.
     #
+    # @param tool_call [RubyLLM::ToolCall, nil] the originating tool call (supplied by the chat)
     # @param args [Hash] the tool arguments from the LLM
     # @return [Object] the tool result or an error string
     # :reek:TooManyStatements -- hook-wrapped dispatch with per-error-class handling; the rescue clauses are the method.
-    def call(args)
+    def call(tool_call: nil, **args)
       context = ToolCallHookContext.new(tool: self, tool_args: args, robot: @robot)
 
       RobotLab::Hooks.run(:tool_call, context, **tool_hook_options) do
@@ -157,15 +158,9 @@ module RobotLab
       tool_class = Class.new(self) do
         description(desc_text) if desc_text
 
-        if params_hash.is_a?(Hash) && params_hash[:properties]
-          required_list = Array(params_hash[:required]).map(&:to_s)
-          params_hash[:properties].each do |pname, pdef|
-            param pname.to_sym,
-                  type: pdef[:type] || "string",
-                  desc: pdef[:description],
-                  required: required_list.include?(pname.to_s)
-          end
-        end
+        # ruby_llm 2.0's parameters() accepts a raw JSON Schema hash, so the
+        # full schema (including nested items/objects) survives verbatim.
+        parameters(params_hash) if params_hash.is_a?(Hash) && params_hash[:properties]
 
         define_method(:execute) do |**args|
           block.call(args)
@@ -183,7 +178,7 @@ module RobotLab
     #
     # @return [Hash] JSON Schema representation
     def to_json_schema
-      schema = params_schema || { "type" => "object", "properties" => {}, "required" => [] }
+      schema = parameters_schema || { "type" => "object", "properties" => {}, "required" => [] }
       {
         name: name,
         description: description,

data/lib/robot_lab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RobotLab
-  VERSION = "0.2.8"
+  VERSION = "0.3.1"
 end

data/lib/robot_lab.rb

@@ -39,7 +39,7 @@ require 'typed_bus'
 #   # See lib/robot_lab/config/defaults.yml for all options
 #
 #   # Access configuration values:
-#   RobotLab.config.ruby_llm.model            #=> "claude-sonnet-4"
+#   RobotLab.config.ruby_llm.model            #=> "claude-sonnet-4-6"
 #   RobotLab.config.ruby_llm.request_timeout  #=> 120
 #
 module RobotLab
@@ -159,7 +159,7 @@ module RobotLab
     # @return [Config] the config instance
     #
     # @example
-    #   RobotLab.config.ruby_llm.model            #=> "claude-sonnet-4"
+    #   RobotLab.config.ruby_llm.model            #=> "claude-sonnet-4-6"
     #   RobotLab.config.ruby_llm.request_timeout  #=> 120
     #   RobotLab.config.development?              #=> true
     def config
@@ -173,7 +173,7 @@ module RobotLab
     #
     # @example
     #   RobotLab.configure do |c|
-    #     c.default_model = "claude-sonnet-4"
+    #     c.default_model = "claude-sonnet-4-6"
     #   end
     def configure
       yield config