brute 5.1.0 → 6.0.0

data/lib/brute/middleware/040_default_compaction_pipeline.rb

@@ -46,10 +46,10 @@ module Brute
     # env[:tools] is not set yet: pass `tools:` to have them counted then.
     #
     # Compaction is lossy, and this layer keeps no record of what it gave up:
-    # it rewrites env[:messages] and says so with :compacted. An application
+    # it rewrites env[:messages] and says so with :compact_end. An application
     # that keeps a transcript preserves it from there.
     #
-    #   agent.on(:compacted) { |env, payload| archive(env, payload) }
+    #   agent.on(:compact_end) { |env, payload| archive(env, payload) }
     #
     class DefaultCompactionPipeline < Brute::Middleware::Base
       def initialize(app, window:, summariser: nil, compactor: nil, keep_steps: 2,
@@ -101,22 +101,25 @@ module Brute
         def compact(env)
           context = estimate(env)
 
-          if context >= @window * @compact_at
-            before = @token_counter.count(env[:messages])
-            compacted = attempt(env, target(env))
-
-            unless compacted.nil?
-              env[:messages].replace(compacted)
-              # The reported total describes a conversation that no longer
-              # exists, so the next estimate must not build on it. The call
-              # below refreshes it; one that fails leaves the estimate to be
-              # counted from scratch instead of anchored to a fiction.
-              env[:metadata]&.delete(:last_llm_usage)
-              emit(
-                COMPACTED_EVENT,
-                env,
-                { context: context, before: before, after: @token_counter.count(compacted) },
-              )
+          env.emit_trace do |env|
+            if context >= @window * @compact_at
+              env.emit(COMPACT_START_EVENT, { context: context })
+
+              before = @token_counter.count(env[:messages])
+              compacted = attempt(env, target(env))
+
+              unless compacted.nil?
+                env[:messages].replace(compacted)
+                # The reported total describes a conversation that no longer
+                # exists, so the next estimate must not build on it. The call
+                # below refreshes it; one that fails leaves the estimate to be
+                # counted from scratch instead of anchored to a fiction.
+                env[:metadata]&.delete(:last_llm_usage)
+                env.emit(
+                  COMPACT_END_EVENT,
+                  { context: context, before: before, after: @token_counter.count(compacted) },
+                )
+              end
             end
           end
         end
@@ -145,18 +148,17 @@ module Brute
         def attempt(env, target)
           compacted = nil
 
-          emit(COMPACT_DURATION_EVENT, env, env[:compactor]) do
+          env.emit(COMPACT_DURATION_EVENT, env[:compactor]) do
             compacted = env[:compactor].compact(
               env[:messages],
-              target: target,
-              events: env[:events] || Brute::Turn::Pipeline::NullSink.new,
+              target:        target,
               token_counter: @token_counter,
             )
           end
 
           compacted
         rescue => error
-          (env[:events] ||= []) << { type: :error, data: { error: error, message: error.message } }
+          env.emit(COMPACT_FAILURE_EVENT, error)
           nil
         end
 
@@ -194,6 +196,10 @@ describe "brute/middleware/040_default_compaction_pipeline" do
     end
   end
 
+  def traced(env, hooks = Brute::Hooks::Registry.new)
+    Brute::Hooks::Trace.new(env, hooks: hooks)
+  end
+
   def compactor(&block)
     Object.new.tap do |double|
       double.define_singleton_method(:compact) { |messages, target:, **| block.call(messages, target) }
@@ -207,6 +213,10 @@ describe "brute/middleware/040_default_compaction_pipeline" do
     declines = compactor { |_messages, target| asked << target; nil }
     raises   = compactor { |_messages, _target| raise IOError, "the summariser is down" }
 
+    hooks = Brute::Hooks::Registry.new
+    %i[compact_end compact_failure].each { |event| hooks.on(event) { |_env, *extras| events << [event, *extras.first(1)] } }
+    hooks.on(:compact_duration) { |_env, *| events << [:compact_duration] }
+
     layer = lambda do |compactor|
       Brute::Middleware::DefaultCompactionPipeline.new(
         ->(env) { env },
@@ -214,18 +224,16 @@ describe "brute/middleware/040_default_compaction_pipeline" do
         window: 1_000,
         compact_at: 0.7,
         compact_to: 0.4,
-      ).tap do |it|
-        it.define_singleton_method(:emit) { |event, _env, *extras, &work| work&.call; events << [event, *extras] }
-      end
+      )
     end
 
-    env = { messages: conversation, metadata: usage(900) }
+    env = traced({ messages: conversation, metadata: usage(900) }, hooks)
     layer.call(shrinks).call(env)
 
     asked.should == [400]
     env[:messages].map(&:role).should == [:user]
     env[:compactor].equal?(shrinks).should.be.true
-    events.select { |e, _| e == :compacted }.should == [[:compacted, { context: 900, before: 514, after: 256 }]]
+    events.select { |e, _| e == :compact_end }.should == [[:compact_end, { context: 900, before: 514, after: 256 }]]
     # The attempt is timed, so the compactor that spends a model call is visible.
     events.select { |e, _| e == :compact_duration }.length.should == 1
 
@@ -233,27 +241,29 @@ describe "brute/middleware/040_default_compaction_pipeline" do
     # asked and nothing is said.
     asked.clear
     events.clear
-    layer.call(shrinks).call({ messages: conversation, metadata: usage(600) })
+    layer.call(shrinks).call(traced({ messages: conversation, metadata: usage(600) }, hooks))
     asked.should == []
     events.should == []
 
     # ...but what landed since it answered is counted on top of it, and that
     # is what tips this one over.
     tail = conversation.tap { |log| log.tool("z" * 400, tool_call_id: "tc1") }
-    layer.call(declines).call({ messages: tail, metadata: usage(600) })
+    layer.call(declines).call(traced({ messages: tail, metadata: usage(600) }, hooks))
     asked.should == [400]
 
     # With nothing reported at all, the whole conversation is counted here.
     asked.clear
-    layer.call(declines).call({ messages: conversation })
+    layer.call(declines).call(traced({ messages: conversation }, hooks))
     asked.should == []
 
     # A compactor that raises is a compactor that declined: reported, not
     # fatal. An agent that cannot shrink its context carries on with it.
-    failing = { messages: conversation, events: [], metadata: usage(900) }
+    events.clear
+    failing = traced({ messages: conversation, metadata: usage(900) }, hooks)
     should.not.raise(IOError) { layer.call(raises).call(failing) }
     failing[:messages].length.should == 2
-    failing[:events].map { |e| [e[:type], e[:data][:message]] }.should == [[:error, "the summariser is down"]]
+    events.select { |e, _| e == :compact_failure }.map { |_, error| error.message }
+      .should == ["the summariser is down"]
 
     # A target at or above the trigger would compact on every single step.
     should.raise(ArgumentError) do
@@ -272,16 +282,11 @@ describe "brute/middleware/040_default_compaction_pipeline" do
     ladder = Brute::Middleware::DefaultCompactionPipeline.compactor(summariser: summariser, keep_steps: 1)
     ladder.should.be.kind_of Brute::Turn::CompactionPipeline
 
-    events = []
-    sink = Object.new.tap { |it| it.define_singleton_method(:<<) { |e| events << e; it } }
-
     messages = history
     before = Brute::Compaction::Transcript.tokens(messages)
-    out = ladder.compact(messages, target: 1_500, events: sink)
+    out = ladder.compact(messages, target: 1_500)
 
     Brute::Compaction::Transcript.tokens(out).should.be < before
-    events.select { |e| e[:type] == :compacted }.map { |e| e[:data][:strategy] }
-      .should.include "sliding_window"
 
     # Given no summariser the terminal declines, and the free layers are all
     # the agent gets -- a policy said out loud rather than configured.
@@ -290,8 +295,7 @@ describe "brute/middleware/040_default_compaction_pipeline" do
 
     # One layer, so it still owns the *when* as well as the what.
     layer = Brute::Middleware::DefaultCompactionPipeline.new(->(e) { e }, window: 1_000, summariser: summariser)
-    layer.define_singleton_method(:emit) { |_e, _env, *, &work| work&.call }
-    env = { messages: history, metadata: {} }
+    env = traced({ messages: history, metadata: {} })
     layer.call(env)
     env[:messages].length.should.be < 11
   end
@@ -319,33 +323,33 @@ describe "brute/middleware/040_default_compaction_pipeline" do
     said = -> { Brute.log.tap { |log| log.user("x" * 2_578) } }
     Brute::TokenCounter.default.count(said.call).should == 650
 
-    layer.call.call({ messages: said.call, metadata: {} })
+    layer.call.call(traced({ messages: said.call, metadata: {} }))
     asked.should == []
 
     # The same conversation ships with tool schemas in every request, and
     # counting what they occupy is what tips it over. What is left of the
     # target after them is what the compactor is asked for -- the schemas are
     # not room the conversation may have.
-    layer.call(tools: [tool]).call({ messages: said.call, metadata: {} })
+    layer.call(tools: [tool]).call(traced({ messages: said.call, metadata: {} }))
     asked.should == [400 - schemas]
 
     # Reported usage already covers the schemas, so the warm path must not
     # count them again -- 600 reported and nothing said since is 600, tools
     # or no tools.
     asked.clear
-    layer.call(tools: [tool]).call({ messages: conversation, metadata: usage(600) })
+    layer.call(tools: [tool]).call(traced({ messages: conversation, metadata: usage(600) }))
     asked.should == []
 
     # What the provider counted describes the conversation as it was. Once
     # compaction has given part of it up that number is a fiction, so it goes
     # -- the next estimate counts from scratch rather than building on it.
-    compacted = { messages: conversation, metadata: usage(900) }
+    compacted = traced({ messages: conversation, metadata: usage(900) })
     layer.call.call(compacted)
     compacted[:messages].length.should == 1
     compacted[:metadata].key?(:last_llm_usage).should.be.false
 
     # Nothing given up, nothing invalidated.
-    kept = { messages: conversation, metadata: usage(900) }
+    kept = traced({ messages: conversation, metadata: usage(900) })
     layer.call(compactor: compactor { |_messages, _target| nil }).call(kept)
     kept[:metadata].key?(:last_llm_usage).should.be.true
   end

data/lib/brute/middleware/070_default_tool_pipeline.rb

@@ -33,7 +33,7 @@ module Brute
           tools_to_run = Array(tools_to_run).reject { |tc| tc.name == "question" }
 
           available_tools = Brute::Tools::Adapter.wrap_all(env[:tools])
-          env[:events] << on_tool_call_start_event(tools_to_run)
+          env.emit(TOOL_CALLS_EVENT, tools_to_run)
 
           results = []
 
@@ -44,47 +44,58 @@ module Brute
             barrier = Async::Barrier.new
 
             tools_to_run.each do |tool_call|
-              barrier.async do 
+              barrier.async do
                 name = tool_call.name.to_sym
                 args = tool_call.arguments
 
-                # Lifecycle hooks (Brute::Hooks): before_tool may rewrite
-                # :arguments or short-circuit with a :result; approve_tool
-                # denies on a false (or String) return; after_tool may
+                # Lifecycle hooks (Brute::Hooks): tool_start may rewrite
+                # :arguments or short-circuit with a :result; tool_approve
+                # denies on a false (or String) return; tool_end may
                 # rewrite :result.
                 call_env = {
                   name:      name.to_s,
                   arguments: args,
                   result:    nil,
                   denied:    nil,
-                  events:    env[:events],
                   metadata:  {},
                   turn_env:  env,
                 }
-                # A subscriber takes part by mutating the call env: set
-                # :result to answer without executing, set :denied to refuse.
-                emit(BEFORE_TOOL_EVENT, env, call_env)
-
-                if call_env[:result].nil?
-                  emit(APPROVE_TOOL_EVENT, env, call_env)
-
-                  if (denial = call_env[:denied])
-                    call_env[:result] = denial.is_a?(String) ? denial : %(Tool call to "#{name}" was denied.)
+                env.emit_trace do |env|
+                  # A subscriber takes part by mutating the call env: set
+                  # :result to answer without executing, set :denied to refuse.
+                  env.emit(TOOL_START_EVENT, call_env)
+
+                  if call_env[:result].nil?
+                    env.emit(TOOL_APPROVE_EVENT, call_env)
+
+                    if (denial = call_env[:denied])
+                      if denial.is_a?(String)
+                        call_env[:result] = denial
+                      else
+                        call_env[:result] = %(Tool call to "#{name}" was denied.)
+                      end
+                    end
                   end
-                end
 
-                # Only the tool's own execution is timed: a call that
-                # before_tool answered, or approve_tool denied, never ran.
-                result = call_env[:result]
+                  # Only the tool's own execution is timed: a call that
+                  # tool_start answered, or tool_approve denied, never ran.
+                  result = call_env[:result]
 
-                if result.nil?
-                  emit(TOOL_DURATION_EVENT, env, call_env) do
-                    result = available_tools[name].call(call_env[:arguments])
+                  if result.nil?
+                    env.emit(TOOL_DURATION_EVENT, call_env) do
+                      result = available_tools[name].call(call_env[:arguments])
+                    end
                   end
-                end
 
-                call_env[:result] = result
-                emit(AFTER_TOOL_EVENT, env, call_env)
+                  call_env[:result] = result
+                  env.emit(TOOL_END_EVENT, call_env)
+                rescue => error
+                  # Capture the error as a tool result so the LLM can see it
+                  # and reason about the failure, rather than crashing the
+                  # entire middleware chain.
+                  env.emit(TOOL_FAILURE_EVENT, call_env, error)
+                  call_env[:result] = "Error: #{error.class}: #{error.message}"
+                end
                 result = call_env[:result]
 
                 # Coerce to String so Hash results (e.g. Shell's
@@ -101,12 +112,6 @@ module Brute
                 end
 
                 results << [tool_call, content]
-              rescue => e
-                # Capture the error as a tool result so the LLM can see it
-                # and reason about the failure, rather than crashing the
-                # entire middleware chain.
-                env[:events] << { type: :error, data: { error: e, message: e.message } }
-                results << [tool_call, "Error: #{e.class}: #{e.message}"]
               end
             end
 
@@ -120,7 +125,6 @@ module Brute
           results.sort_by! { |tool_call, _| tools_to_run.index(tool_call) }
 
           results.each do |tool_call, content|
-            env[:events] << { type: :tool_result, data: { name: tool_call.name, content: content } }
             env[:messages] << Brute::Message.new(role: :tool, content: content, tool_call_id: tool_call.id)
           end
         end
@@ -129,19 +133,6 @@ module Brute
       end
 
       private
-
-        def on_tool_call_start_event(pending_tools)
-          {
-            type: :tool_call_start,
-            data: pending_tools.map { |tc|
-              {
-                name: tc.name,
-                call_id: tc.id,
-                arguments: tc.arguments
-              }
-            }
-          }
-        end
     end
   end
 end
@@ -193,7 +184,7 @@ describe "brute/middleware/070_default_tool_pipeline" do
     { messages: Brute.log, events: [] }
   end
 
-  it "before_tool may rewrite arguments and short-circuit with a result" do
+  it "tool_start may rewrite arguments and short-circuit with a result" do
     tool = { name: "echo", description: "", execute: ->(text:) { "ran:#{text}" } }
     inner = ->(env) do
       env[:messages] << Brute::Message.new(role: :assistant, content: "",
@@ -201,41 +192,41 @@ describe "brute/middleware/070_default_tool_pipeline" do
     end
 
     pipeline = hooked(inner, tools: [tool]) do |p|
-      p.on(:before_tool) { |_env, call| call[:arguments] = { text: "rewritten" } }
+      p.on(:tool_start) { |_env, call| call[:arguments] = { text: "rewritten" } }
     end
     env = hook_env
     env[:messages].user("hi")
     pipeline.call(env)
     env[:messages].last.content.should == "ran:rewritten"
 
-    canned = hooked(inner, tools: [tool]) { |p| p.on(:before_tool) { |_env, call| call[:result] = "canned" } }
+    canned = hooked(inner, tools: [tool]) { |p| p.on(:tool_start) { |_env, call| call[:result] = "canned" } }
     env2 = hook_env
     env2[:messages].user("hi")
     canned.call(env2)
     env2[:messages].last.content.should == "canned" # never executed
   end
 
-  it "approve_tool denies on false (generic message) or String (custom)" do
+  it "tool_approve denies on false (generic message) or String (custom)" do
     tool = { name: "exec", description: "", execute: ->(**) { "ran" } }
     inner = ->(env) do
       env[:messages] << Brute::Message.new(role: :assistant, content: "",
         tool_calls: [{ id: "tc1", name: "exec", arguments: {} }])
     end
 
-    denied = hooked(inner, tools: [tool]) { |p| p.on(:approve_tool) { |_env, call| call[:denied] = true } }
+    denied = hooked(inner, tools: [tool]) { |p| p.on(:tool_approve) { |_env, call| call[:denied] = true } }
     env = hook_env
     env[:messages].user("hi")
     denied.call(env)
     env[:messages].last.content.should == %(Tool call to "exec" was denied.)
 
-    by_policy = hooked(inner, tools: [tool]) { |p| p.on(:approve_tool) { |_env, call| call[:denied] = "denied by policy" } }
+    by_policy = hooked(inner, tools: [tool]) { |p| p.on(:tool_approve) { |_env, call| call[:denied] = "denied by policy" } }
     env2 = hook_env
     env2[:messages].user("hi")
     by_policy.call(env2)
     env2[:messages].last.content.should == "denied by policy"
   end
 
-  it "after_tool may rewrite the result" do
+  it "tool_end may rewrite the result" do
     tool = { name: "echo", description: "", execute: ->(**) { "raw" } }
     inner = ->(env) do
       env[:messages] << Brute::Message.new(role: :assistant, content: "",
@@ -243,7 +234,7 @@ describe "brute/middleware/070_default_tool_pipeline" do
     end
 
     pipeline = hooked(inner, tools: [tool]) do |p|
-      p.on(:after_tool) { |_env, call| call[:result] = "rewrote(#{call[:result]})" }
+      p.on(:tool_end) { |_env, call| call[:result] = "rewrote(#{call[:result]})" }
     end
     env = hook_env
     env[:messages].user("hi")

data/lib/brute/prompt_template.rb

@@ -56,25 +56,29 @@ module Brute
 
     private
 
-    def locals(ctx)
-      @section_keys.to_h do |key|
-        value = self[key]
-        resolved = value.is_a?(Proc) ? (value.arity.zero? ? value.call : value.call(ctx)) : value
-        [key, resolved]
-      end.merge(ctx: ctx)
-    end
+      def locals(ctx)
+        @section_keys.to_h do |key|
+          value = self[key]
+          if value.is_a?(Proc)
+            resolved = (value.arity.zero? ? value.call : value.call(ctx))
+        else
+          resolved = value
+        end
+          [key, resolved]
+        end.merge(ctx: ctx)
+      end
 
-    def render(values)
-      context = binding
-      values.each { |key, value| context.local_variable_set(key, value) }
-      ERB.new(template_source, trim_mode: "-").result(context)
-    end
+      def render(values)
+        context = binding
+        values.each { |key, value| context.local_variable_set(key, value) }
+        ERB.new(template_source, trim_mode: "-").result(context)
+      end
 
     # A path that exists is re-read every time; anything else is treated as
     # an inline ERB source string.
-    def template_source
-      File.exist?(@template.to_s) ? File.read(@template) : @template.to_s
-    end
+      def template_source
+        File.exist?(@template.to_s) ? File.read(@template) : @template.to_s
+      end
   end
 end
 

data/lib/brute/prompts/base.rb

@@ -14,9 +14,14 @@ module Brute
     def self.read(section, provider_name)
       provider = provider_name.to_s
       path = File.join(TEXT_DIR, section, "#{provider}.txt")
-      path = File.join(TEXT_DIR, section, "default.txt") unless File.exist?(path)
-      return nil unless File.exist?(path)
-      File.read(path)
+      unless File.exist?(path)
+        path = File.join(TEXT_DIR, section, "default.txt")
+      end
+      if File.exist?(path)
+        File.read(path)
+      else
+        nil
+      end
     end
 
     # Read a named agent prompt (e.g. "explore", "compaction").
@@ -33,9 +38,11 @@ module Brute
       end
 
       def method_missing(name, *args)
-        return @ctx[name] if args.empty? && @ctx.key?(name)
-
-        super
+        if args.empty? && @ctx.key?(name)
+          @ctx[name]
+        else
+          super
+        end
       end
 
       def respond_to_missing?(name, include_private = false)
@@ -69,10 +76,12 @@ module Brute
       path = [provider, "default"]
              .map { |variant| File.join(TEXT_DIR, section, "#{variant}.erb") }
              .find { |candidate| File.exist?(candidate) }
-      return read(section, provider) unless path
-
-      erb = TEMPLATES[path] ||= ERB.new(File.read(path), trim_mode: "-")
-      erb.result(Context.new(ctx).get_binding)
+      if path
+        erb = TEMPLATES[path] ||= ERB.new(File.read(path), trim_mode: "-")
+        erb.result(Context.new(ctx).get_binding)
+      else
+        read(section, provider)
+      end
     end
   end
 end

data/lib/brute/prompts/environment.rb

@@ -12,7 +12,9 @@ module Brute
         git = File.exist?(File.join(cwd, ".git"))
 
         parts = []
-        parts << "You are powered by the model named #{model}." unless model.empty?
+        unless model.empty?
+          parts << "You are powered by the model named #{model}."
+        end
         parts << ""
         parts << "Here is some useful information about the environment you are running in:"
         parts << "<env>"

data/lib/brute/prompts/instructions.rb

@@ -8,13 +8,15 @@ module Brute
     module Instructions
       def self.call(ctx)
         rules = ctx[:custom_rules]
-        return nil if rules.nil? || rules.strip.empty?
-
-        <<~TXT
-          # Project-Specific Rules
-
-          #{rules}
-        TXT
+        if rules.nil? || rules.strip.empty?
+          nil
+        else
+          <<~TXT
+            # Project-Specific Rules
+
+            #{rules}
+          TXT
+        end
       end
     end
   end

data/lib/brute/prompts/skills.rb

@@ -16,9 +16,11 @@ module Brute
       def self.call(ctx)
         skills = ctx[:skills] || Brute::Skill.all(cwd: ctx[:cwd] || Dir.pwd)
         visible = skills.reject(&:disable_model_invocation?)
-        return nil if visible.empty?
-
-        Prompts.render("skills", ctx.merge(skills: visible))
+        if visible.empty?
+          nil
+        else
+          Prompts.render("skills", ctx.merge(skills: visible))
+        end
       end
     end
   end

data/lib/brute/rack/adapter.rb

@@ -38,7 +38,9 @@ module Brute
       # @parameter agent [#start] Anything with `start(prompt) -> env` — an
       #   AgentPipeline, a SubAgent, or any turn-shaped callable.
       def initialize(agent)
-        raise ArgumentError, "agent must respond to #start" unless agent.respond_to?(:start)
+        unless agent.respond_to?(:start)
+          raise ArgumentError, "agent must respond to #start"
+        end
 
         @agent = agent
       end
@@ -48,10 +50,12 @@ module Brute
       # (client's fault); anything the turn raises is a 500.
       def call(env)
         prompt = prompt_from(env)
-        return response_for(env, 400, "No prompt provided.") if prompt.nil? || prompt.empty?
-
-        turn = @agent.start(prompt)
-        response_for(env, 200, output_of(turn))
+        if prompt.nil? || prompt.empty?
+          response_for(env, 400, "No prompt provided.")
+        else
+          turn = @agent.start(prompt)
+          response_for(env, 200, output_of(turn))
+        end
       rescue => error
         response_for(env, 500, error.message)
       end
@@ -68,24 +72,29 @@ module Brute
         request = ::Rack::Request.new(env)
 
         if (query = request.GET["prompt"]) && !query.empty?
-          return query
-        end
-
-        body = read_body(request)
-        return nil if body.nil? || body.strip.empty?
-
-        if json?(request.media_type)
-          case data = parse_json(body)
-          when ::Hash   then return PROMPT_KEYS.filter_map { |key| data[key] }.first&.to_s || body
-          when ::String then return data
+          query
+        else
+          body = read_body(request)
+          if body.nil? || body.strip.empty?
+            nil
+          else
+            from_json = nil
+            if json?(request.media_type)
+              case data = parse_json(body)
+              when ::Hash   then from_json = PROMPT_KEYS.filter_map { |key| data[key] }.first&.to_s || body
+              when ::String then from_json = data
+              end
+            end
+
+            if from_json
+              from_json
+            elsif request.form_data? && (field = ::Rack::Utils.parse_nested_query(body)["prompt"])
+              field
+            else
+              body
+            end
           end
         end
-
-        if request.form_data? && (field = ::Rack::Utils.parse_nested_query(body)["prompt"])
-          return field
-        end
-
-        body
       end
 
       # output -> [status, headers, body]. Content-negotiated: JSON in (or an
@@ -96,7 +105,11 @@ module Brute
         text = output.to_s
 
         if wants_json?(env)
-          key = status == 200 ? :response : :error
+          if status == 200
+            key = :response
+          else
+            key = :error
+          end
           [status, {"content-type" => "application/json"}, [::JSON.generate(key => text)]]
         else
           [status, {"content-type" => "text/plain; charset=utf-8"}, [text]]
@@ -107,7 +120,11 @@ module Brute
 
         # The agent's answer is the last message it appended to the log.
         def output_of(turn)
-          messages = turn.is_a?(::Hash) ? turn[:messages] : turn
+          if turn.is_a?(::Hash)
+            messages = turn[:messages]
+          else
+            messages = turn
+          end
           messages&.last&.content.to_s
         end