brute 5.1.0 → 6.0.0

data/lib/brute/message_transport/llm.rb

@@ -39,8 +39,11 @@ module Brute
             wire = message.tool_calls.map do |tc|
               { id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.generate(tc.arguments) } }
             end
-            ::LLM::Message.new(:assistant, message.content.to_s,
-                               { tool_calls: wire, original_tool_calls: wire })
+            ::LLM::Message.new(
+              :assistant,
+              message.content.to_s,
+              { tool_calls: wire, original_tool_calls: wire },
+            )
           else
             ::LLM::Message.new(:assistant, message.content)
           end
@@ -53,8 +56,9 @@ module Brute
 
         # LLM::Message (from an LLM::Response) -> Brute::Message.
         def wrap(message)
-          tool_calls = if message.tool_call?
-            message.tool_calls.map do |tc|
+          tool_calls = nil
+          if message.tool_call?
+            tool_calls = message.tool_calls.map do |tc|
               Brute::ToolCall.new(id: tc.id, name: tc["name"], arguments: tc.arguments.to_h)
             end
           end

data/lib/brute/message_transport/open_router.rb

@@ -26,9 +26,11 @@ module Brute
       # An OpenRouter::Response's messages (one per choice; in practice
       # OpenRouter returns exactly one).
       def messages
-        return @result.choices.map { |choice| choice["message"] || choice[:message] } if @result.respond_to?(:choices)
-
-        super
+        if @result.respond_to?(:choices)
+          @result.choices.map { |choice| choice["message"] || choice[:message] }
+        else
+          super
+        end
       end
 
       private
@@ -36,14 +38,25 @@ module Brute
         def wrap(message)
           # Coerce string keys to symbol keys if necessary
           hash = message.to_h.transform_keys(&:to_sym)
-          hash[:role] = hash[:role].to_sym if hash.key?(:role)
-          hash[:tool_calls] = hash[:tool_calls].map { |tc| wrap_tool_call(tc) } if hash[:tool_calls]
+          if hash.key?(:role)
+            hash[:role] = hash[:role].to_sym
+          end
+          if hash[:tool_calls]
+            hash[:tool_calls] = hash[:tool_calls].map { |tc| wrap_tool_call(tc) }
+          end
 
           case hash
           in { role: (:system | :user | :assistant | :tool) }
             # Slice away provider extras (refusal, reasoning, model, ...)
             # that Brute::Message doesn't know.
-            Brute::Message.new(**hash.slice(:role, :content, :tool_calls, :tool_call_id))
+            Brute::Message.new(
+              **hash.slice(
+                :role,
+                :content,
+                :tool_calls,
+                :tool_call_id,
+              ),
+            )
           else
             raise "Unrecognised message format #{message.inspect}"
           end
@@ -53,16 +66,17 @@ module Brute
         # -> the flat { id:, name:, arguments: Hash } Brute::Message understands.
         def wrap_tool_call(tool_call)
           tc = tool_call.to_h.transform_keys(&:to_sym)
-          return tc unless tc[:function] # already flat { id:, name:, arguments: }
-
-          function = tc[:function].to_h.transform_keys(&:to_sym)
-          arguments = function[:arguments].to_s
-
-          {
-            id: tc[:id],
-            name: function[:name],
-            arguments: JSON.parse(arguments.empty? ? "{}" : arguments),
-          }
+          if tc[:function]
+            function = tc[:function].to_h.transform_keys(&:to_sym)
+            arguments = function[:arguments].to_s
+            {
+              id:        tc[:id],
+              name:      function[:name],
+              arguments: JSON.parse(arguments.empty? ? "{}" : arguments),
+            }
+          else
+            tc
+          end
         end
     end
   end

data/lib/brute/message_transport/openai.rb

@@ -28,9 +28,14 @@ module Brute
           { role: "tool", tool_call_id: message.tool_call_id, content: message.content.to_s }
         when :assistant
           if message.tool_call?
+            content = message.content
+            if content.to_s.empty?
+              content = nil
+            end
+
             {
               role:       "assistant",
-              content:    (message.content unless message.content.to_s.empty?),
+              content:    content,
               tool_calls: message.tool_calls.map { |tc|
                 { id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.generate(tc.arguments) } }
               },
@@ -45,9 +50,11 @@ module Brute
 
       # A chat completion response's messages (one per choice).
       def messages
-        return @result.choices.map(&:message) if @result.respond_to?(:choices)
-
-        super
+        if @result.respond_to?(:choices)
+          @result.choices.map(&:message)
+        else
+          super
+        end
       end
 
       private
@@ -56,10 +63,10 @@ module Brute
         # arguments arrive as a JSON string; parse them into a Hash.
         def wrap(message)
           tool_calls = message.tool_calls&.map do |tc|
-            arguments = begin
-              JSON.parse(tc.function.arguments.to_s)
+            begin
+              arguments = JSON.parse(tc.function.arguments.to_s)
             rescue JSON::ParserError
-              {}
+              arguments = {}
             end
             Brute::ToolCall.new(id: tc.id, name: tc.function.name, arguments: arguments)
           end

data/lib/brute/message_transport/ruby_llm.rb

@@ -24,32 +24,36 @@ module Brute
           role:         message.role,
           content:      message.content,
           tool_calls:   tool_calls,
-          tool_call_id: message.tool_call_id
+          tool_call_id: message.tool_call_id,
         )
       end
 
       private
 
       # RubyLLM::Message -> Brute::Message.
-      def wrap(message)
-        raw_calls = message.tool_calls
-        calls_list = raw_calls.respond_to?(:values) ? raw_calls.values : raw_calls
+        def wrap(message)
+          raw_calls = message.tool_calls
+          if raw_calls.respond_to?(:values)
+            calls_list = raw_calls.values
+        else
+          calls_list = raw_calls
+        end
+
+          tool_calls = calls_list&.map do |tc|
+            Brute::ToolCall.new(
+              id:        tc.id,
+              name:      tc.name,
+              arguments: tc.arguments,
+            )
+          end
 
-        tool_calls = calls_list&.map do |tc|
-          Brute::ToolCall.new(
-            id:        tc.id,
-            name:      tc.name,
-            arguments: tc.arguments
+          Brute::Message.new(
+            role:         message.role,
+            content:      message.content&.to_s, # Preserves nil safely
+            tool_calls:   tool_calls,
+            tool_call_id: message.tool_call_id,
           )
         end
-
-        Brute::Message.new(
-          role:         message.role,
-          content:      message.content&.to_s, # Preserves nil safely
-          tool_calls:   tool_calls,
-          tool_call_id: message.tool_call_id
-        )
-      end
     end
   end
 end

data/lib/brute/message_transport/ruby_open_ai.rb

@@ -4,80 +4,82 @@ module Brute
 
       # Brute::Message -> ruby-openai Hash payload
       def self.dump(message)
-        payload = {
-          role: message.role.to_s
-        }
-
-        # Include content if present
-        payload[:content] = message.content if message.content
+        {
+          role: message.role.to_s,
+        }.tap do |payload|
+          # Include content if present
+          if message.content
+            payload[:content] = message.content
+          end
 
-        # Include tool call ID for tool outputs
-        payload[:tool_call_id] = message.tool_call_id if message.tool_call_id
+          # Include tool call ID for tool outputs
+          if message.tool_call_id
+            payload[:tool_call_id] = message.tool_call_id
+          end
 
-        # Convert Brute::ToolCall objects to ruby-openai nested tool call hashes
-        if message.tool_call?
-          payload[:tool_calls] = message.tool_calls.map do |tc|
-            {
-              id: tc.id,
-              type: "function",
-              function: {
-                name: tc.name,
-                arguments: tc.arguments.is_a?(String) ? tc.arguments : tc.arguments.to_json
+          # Convert Brute::ToolCall objects to ruby-openai nested tool call hashes
+          if message.tool_call?
+            payload[:tool_calls] = message.tool_calls.map do |tc|
+              {
+                id:       tc.id,
+                type:     "function",
+                function: {
+                  name:      tc.name,
+                  arguments: tc.arguments.is_a?(String) ? tc.arguments : tc.arguments.to_json,
+                },
               }
-            }
+            end
           end
         end
-
-        payload
       end
 
       private
 
       # ruby-openai Hash (or API response choice message) -> Brute::Message
-      def wrap(message)
-        # Normalize keys to symbols for pattern matching
-        hash = message.to_h.transform_keys(&:to_sym)
+        def wrap(message)
+          # Normalize keys to symbols for pattern matching
+          hash = message.to_h.transform_keys(&:to_sym)
 
-        case hash
-        # Branch 1: System, User, or Tool responses with text content
-        in { role: ("system" | "user" | "tool") => role }
-          Brute::Message.new(
-            role: role,
-            content: hash[:content],
-            tool_call_id: hash[:tool_call_id]
-          )
+          case hash
+          # Branch 1: System, User, or Tool responses with text content
+          in { role: ("system" | "user" | "tool") => role }
+            Brute::Message.new(
+              role:         role,
+              content:      hash[:content],
+              tool_call_id: hash[:tool_call_id],
+            )
 
-        # Branch 2: Assistant tool calls request
-        in { role: "assistant", tool_calls: Array => raw_calls }
-          tool_calls = raw_calls.map do |tc|
-            # Handle both string and symbol keys within nested tool_call hashes
-            tc_hash = tc.to_h.transform_keys(&:to_sym)
-            fn_hash = (tc_hash[:function] || {}).transform_keys(&:to_sym)
+          # Branch 2: Assistant tool calls request
+          in { role: "assistant", tool_calls: Array => raw_calls }
+            tool_calls = raw_calls.map do |tc|
+              # Handle both string and symbol keys within nested tool_call hashes
+              tc_hash = tc.to_h.transform_keys(&:to_sym)
+              fn_hash = (tc_hash[:function] || {}).transform_keys(&:to_sym)
 
-            Brute::ToolCall.new(
-              id: tc_hash[:id],
-              name: fn_hash[:name],
-              arguments: fn_hash[:arguments]
-            )
-          end
+              Brute::ToolCall.new(
+                id:        tc_hash[:id],
+                name:      fn_hash[:name],
+                arguments: fn_hash[:arguments],
+              )
+            end
 
-          Brute::Message.new(
-            role: :assistant,
-            content: hash[:content],
-            tool_calls: tool_calls
-          )
+            Brute::Message.new(
+              role:       :assistant,
+              content:    hash[:content],
+              tool_calls: tool_calls,
+            )
 
-        # Branch 3: Standard Assistant text message
-        in { role: "assistant" }
-          Brute::Message.new(
-            role: :assistant,
-            content: hash[:content]
-          )
+          # Branch 3: Standard Assistant text message
+          in { role: "assistant" }
+            Brute::Message.new(
+              role:    :assistant,
+              content: hash[:content],
+            )
 
-        else
-          raise "Unrecognised message format for ruby-openai: #{message.inspect}"
+          else
+            raise "Unrecognised message format for ruby-openai: #{message.inspect}"
+          end
         end
-      end
     end
   end
 end

data/lib/brute/messages.rb

@@ -22,27 +22,34 @@ module Brute
   #     Brute::ToolCall.new(id: "tc1", name: "shell", arguments: { "command" => "ls" }),
   #   ])
   #   Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
-  Message = Data.define(:role, :content, :tool_calls, :tool_call_id) do
+  Message = Data.define(
+    :role,
+    :content,
+    :tool_calls,
+    :tool_call_id,
+  ) do
     def initialize(role:, content: nil, tool_calls: nil, tool_call_id: nil)
       formatted_calls = tool_calls&.map do |tc|
         tc.is_a?(ToolCall) ? tc : ToolCall.new(**tc.to_h.transform_keys(&:to_sym))
       end
-  
+
       super(
-        role: role.to_sym,
-        content: content,
-        tool_calls: formatted_calls,
+        role:         role.to_sym,
+        content:      content,
+        tool_calls:   formatted_calls,
         tool_call_id: tool_call_id
       )
     end
-  
+
     def tool_call? = !tool_calls.nil? && !tool_calls.empty?
     alias_method :has_tool_calls?, :tool_call?
-  
+
     # Clean, JSON-ready hash export dropping nil values
     def to_h(...)
       hash = super
-      hash[:tool_calls] = tool_calls.map(&:to_h) if tool_calls
+      if tool_calls
+        hash[:tool_calls] = tool_calls.map(&:to_h)
+      end
       hash.compact
     end
   end

data/lib/brute/middleware/000_base.rb

@@ -11,13 +11,13 @@ module Brute
     #
     #   class Shout < Brute::Middleware::Base
     #     def call(env)
-    #       emit(ENTER_EVENT, env, self)
+    #       env.emit(MIDDLEWARE_START_EVENT, self)
     #       @app.call(env)
     #     end
     #   end
     #
     # Brute::Hooks is included, so the event names are first class in every
-    # subclass — ENTER_EVENT, not Brute::Hooks::ENTER_EVENT.
+    # subclass — MIDDLEWARE_START_EVENT, not Brute::Hooks::MIDDLEWARE_START_EVENT.
     class Base
       include Brute::Hooks
 
@@ -49,9 +49,9 @@ describe "brute/middleware/000_base" do
     Brute::Middleware::Base.new(terminal, :extra, keyword: true).call({}).should == {}
 
     # The event names resolve through the class itself, so a subclass writes
-    # ENTER_EVENT rather than Brute::Hooks::ENTER_EVENT.
-    Brute::Middleware::Base.const_get(:ENTER_EVENT).should == :enter
-    Brute::Middleware::SystemPrompt.const_get(:AFTER_TOOL_EVENT).should == :after_tool
+    # MIDDLEWARE_START_EVENT rather than Brute::Hooks::MIDDLEWARE_START_EVENT.
+    Brute::Middleware::Base.const_get(:MIDDLEWARE_START_EVENT).should == :middleware_start
+    Brute::Middleware::SystemPrompt.const_get(:TOOL_END_EVENT).should == :tool_end
 
     # Every middleware in the chain descends from it.
     Brute::Middleware::SystemPrompt.ancestors.should.include Brute::Middleware::Base

data/lib/brute/middleware/002_session_log.rb

@@ -30,9 +30,13 @@ module Brute
       end
 
       def call(env)
-        load_into(env[:messages]) if @path && File.exist?(@path)
+        if @path && File.exist?(@path)
+          load_into(env[:messages])
+        end
         @app.call(env)
-        persist(env[:messages]) if @path
+        if @path
+          persist(env[:messages])
+        end
         env
       end
 
@@ -42,7 +46,9 @@ module Brute
           loaded = []
           File.foreach(@path) do |line|
             line = line.strip
-            loaded << Brute::Message.new(**JSON.parse(line, symbolize_names: true)) unless line.empty?
+            unless line.empty?
+              loaded << Brute::Message.new(**JSON.parse(line, symbolize_names: true))
+            end
           end
           messages.unshift(*loaded)
         end
@@ -51,7 +57,9 @@ module Brute
           FileUtils.mkdir_p(File.dirname(@path))
           File.open(@path, "w") do |f|
             messages.each do |message|
-              next if message.role == :system
+              if message.role == :system
+                next
+              end
 
               f.puts(JSON.generate(message.to_h))
             end

data/lib/brute/middleware/008_checkpoint.rb

@@ -41,7 +41,9 @@ module Brute
       end
 
       def call(env)
-        restore(env) unless env[:metadata][:checkpoint]
+        unless env[:metadata][:checkpoint]
+          restore(env)
+        end
         @app.call(env)
         persist(env)
         env
@@ -50,11 +52,15 @@ module Brute
       # Parsed checkpoint records (symbol keys, messages as plain hashes),
       # oldest first.
       def self.list(path)
-        return [] unless path && File.exist?(path)
-
-        File.foreach(path).filter_map do |line|
-          line = line.strip
-          JSON.parse(line, symbolize_names: true) unless line.empty?
+        if path && File.exist?(path)
+          File.foreach(path).filter_map do |line|
+            line = line.strip
+            unless line.empty?
+              JSON.parse(line, symbolize_names: true)
+            end
+          end
+        else
+          []
         end
       end
 
@@ -62,19 +68,21 @@ module Brute
 
         def restore(env)
           env[:metadata][:checkpoint] = { path: @path }
-          return unless @resume
-
-          record = find_record
-          if record.nil?
-            return if @resume == :latest
-
-            raise KeyError, "no checkpoint #{@resume.inspect} in #{@path}"
+          if @resume
+            record = find_record
+            if record.nil?
+              unless @resume == :latest
+                raise KeyError, "no checkpoint #{@resume.inspect} in #{@path}"
+              end
+            else
+              history = record[:messages].map { |h| Brute::Message.new(**h) }
+              index = env[:messages].index { |m| m.role != :system } || env[:messages].size
+              env[:messages].insert(index, *history)
+              env[:metadata][:checkpoint][:id] = record[:id]
+            end
+          else
+            nil
           end
-
-          history = record[:messages].map { |h| Brute::Message.new(**h) }
-          index = env[:messages].index { |m| m.role != :system } || env[:messages].size
-          env[:messages].insert(index, *history)
-          env[:metadata][:checkpoint][:id] = record[:id]
         end
 
         def find_record

data/lib/brute/middleware/010_max_iterations.rb

@@ -23,7 +23,7 @@ module Brute
       def call(env)
         if max_iterations_reached?(env)
           env[:messages] << Brute::Message.new(
-            role: :user,
+            role:    :user,
             content: "Maximum iterations reached.",
           )
         else

data/lib/brute/middleware/020_system_prompt.rb

@@ -37,7 +37,7 @@ module Brute
           result = @system_prompt.prepare(ctx)
           unless result.empty?
             env[:messages].unshift(
-              Brute::Message.new(role: :system, content: result.to_s)
+              Brute::Message.new(role: :system, content: result.to_s),
             )
           end
         end