brute 5.0.5 → 6.0.0

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,13 +49,13 @@ 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
-    Brute::Middleware::ToolPipeline.ancestors.should.include Brute::Middleware::Base
+    Brute::Middleware::DefaultToolPipeline.ancestors.should.include Brute::Middleware::Base
     Brute::Middleware::Loop::ToolResult.ancestors.should.include Brute::Middleware::Base
   end
 end

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

@@ -16,7 +16,7 @@ module Brute
     #   use Brute::Middleware::Loop::ToolResult
     #   use Brute::Middleware::Checkpoint, path: "tmp/checkpoints.jsonl"
     #   use Brute::Middleware::MaxIterations
-    #   use Brute::Middleware::ToolPipeline, tools: Brute::Tools::ALL
+    #   use Brute::Middleware::DefaultToolPipeline, tools: Brute::Tools::ALL
     #
     # The store is just a JSONL log of snapshots — one line per checkpoint,
     # each carrying the full message log plus its own id and the id of the
@@ -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