brute 5.1.0 → 6.0.0

data/lib/brute/contrib/otel.rb

@@ -19,8 +19,8 @@ module Brute
     # Every event it needs already exists:
     #
     #   turn_start / turn_end   the span itself
-    #   after_llm               token usage, from env[:metadata][:last_llm_usage]
-    #   before_tool / after_tool a span event per tool call and result
+    #   llm_end               token usage, from env[:metadata][:last_llm_usage]
+    #   tool_start / tool_end   a span event per tool call and result
     #
     # The tracer is injectable; without one it asks OpenTelemetry, and when
     # the SDK is not loaded `subscribe` does nothing at all.
@@ -35,33 +35,50 @@ module Brute
 
       class << self
         def subscribe(agent, tracer: default_tracer)
-          return agent if tracer.nil?
-
-          agent
-            .on(Brute::Hooks::TURN_START_EVENT) { |env| start(env, tracer) }
-            .on(Brute::Hooks::TURN_END_EVENT) { |env| finish(env) }
-            .on(Brute::Hooks::AFTER_LLM_EVENT) { |env| record_usage(env) }
-            .on(Brute::Hooks::BEFORE_TOOL_EVENT) { |env, call| tool_called(env, call) }
-            .on(Brute::Hooks::AFTER_TOOL_EVENT) { |env, call| tool_returned(env, call) }
-            .on(Brute::Hooks::LLM_FAILURE_EVENT) { |env| failed(env) }
-            .on(Brute::Hooks::DURATION_EVENT) { |env, started, finished, layer| layer_finished(env, started, finished, layer) }
-            .on(Brute::Hooks::TURN_DURATION_EVENT) { |env, started, finished| timed(env, "turn", finished - started) }
-            .on(Brute::Hooks::LLM_DURATION_EVENT) { |env, started, finished| timed(env, "llm", finished - started) }
-            .on(Brute::Hooks::TOOL_DURATION_EVENT) { |env, started, finished, call| timed(env, "tool", finished - started, "tool.name" => call[:name].to_s) }
+          if tracer.nil?
+            agent
+          else
+            agent
+              .on(Brute::Hooks::TURN_START_EVENT) { |env| start(env, tracer) }
+              .on(Brute::Hooks::TURN_END_EVENT) { |env| finish(env) }
+              .on(Brute::Hooks::LLM_END_EVENT) { |env| record_usage(env) }
+              .on(Brute::Hooks::TOOL_START_EVENT) { |env, call| tool_called(env, call) }
+              .on(Brute::Hooks::TOOL_END_EVENT) { |env, call| tool_returned(env, call) }
+              .on(Brute::Hooks::LLM_FAILURE_EVENT) { |env| failed(env) }
+              .on(Brute::Hooks::MIDDLEWARE_DURATION_EVENT) { |env, started, finished, layer| layer_finished(
+                env,
+                started,
+                finished,
+                layer,
+              ) }
+              .on(Brute::Hooks::TURN_DURATION_EVENT) { |env, started, finished| timed(env, "turn", finished - started) }
+              .on(Brute::Hooks::LLM_DURATION_EVENT) { |env, started, finished| timed(env, "llm", finished - started) }
+              .on(Brute::Hooks::TOOL_DURATION_EVENT) { |env, started, finished, call| timed(
+                env,
+                "tool",
+                finished - started,
+                "tool.name" => call[:name].to_s,
+              ) }
+          end
         end
 
         def default_tracer
-          return nil unless defined?(::OpenTelemetry)
-
-          ::OpenTelemetry.tracer_provider.tracer("brute", Brute::VERSION)
+          if defined?(::OpenTelemetry)
+            ::OpenTelemetry.tracer_provider.tracer("brute", Brute::VERSION)
+          else
+            nil
+          end
         end
 
         private
 
           def start(env, tracer)
-            env[:span] = tracer.start_span(SPAN_NAME, attributes: {
-              "brute.messages" => env[:messages]&.size,
-            }.compact)
+            env[:span] = tracer.start_span(
+              SPAN_NAME,
+              attributes: {
+                "brute.messages" => env[:messages]&.size,
+              }.compact,
+            )
           end
 
           def finish(env)
@@ -73,40 +90,55 @@ module Brute
           # arrives under the same names, and what it did not report is
           # absent rather than zero.
           def record_usage(env)
-            span = env[:span] or return
-            usage = env.dig(:metadata, :last_llm_usage) or return
-
-            {
-              "gen_ai.usage.input_tokens"     => usage.input,
-              "gen_ai.usage.output_tokens"    => usage.output,
-              "gen_ai.usage.total_tokens"     => usage.total,
-              "gen_ai.usage.reasoning_tokens" => usage.reasoning,
-              "gen_ai.usage.cache_read_tokens" => usage.cache_read,
-              "gen_ai.usage.cost"             => usage.cost,
-            }.each { |name, value| span.set_attribute(name, value) unless value.nil? }
+            span  = env[:span]
+            usage = env.dig(:metadata, :last_llm_usage)
+
+            if span && usage
+              {
+                "gen_ai.usage.input_tokens"      => usage.input,
+                "gen_ai.usage.output_tokens"     => usage.output,
+                "gen_ai.usage.total_tokens"      => usage.total,
+                "gen_ai.usage.reasoning_tokens"  => usage.reasoning,
+                "gen_ai.usage.cache_read_tokens" => usage.cache_read,
+                "gen_ai.usage.cost"              => usage.cost,
+              }.each do |name, value|
+                unless value.nil?
+                  span.set_attribute(name, value)
+                end
+              end
+            end
           end
 
           def tool_called(env, call)
-            env[:span]&.add_event("tool_call", attributes: {
-              "tool.name"      => call[:name].to_s,
-              "tool.arguments" => call[:arguments].to_s,
-            })
+            env[:span]&.add_event(
+              "tool_call",
+              attributes: {
+                "tool.name"      => call[:name].to_s,
+                "tool.arguments" => call[:arguments].to_s,
+              },
+            )
           end
 
           def tool_returned(env, call)
-            env[:span]&.add_event("tool_result", attributes: {
-              "tool.name"  => call[:name].to_s,
-              "tool.bytes" => call[:result].to_s.bytesize,
-            })
+            env[:span]&.add_event(
+              "tool_result",
+              attributes: {
+                "tool.name"  => call[:name].to_s,
+                "tool.bytes" => call[:result].to_s.bytesize,
+              },
+            )
           end
 
-          # The layer's work is :duration's block, so start and finish arrive
-          # with it rather than having to be correlated with :enter by hand.
+          # The layer's work is :middleware_duration's block, so start and finish arrive
+          # with it rather than having to be correlated with :middleware_start by hand.
           def layer_finished(env, started, finished, layer)
-            env[:span]&.add_event("middleware", attributes: {
-              "middleware.name"     => layer.class.name.to_s,
-              "middleware.duration" => finished - started,
-            })
+            env[:span]&.add_event(
+              "middleware",
+              attributes: {
+                "middleware.name"     => layer.class.name.to_s,
+                "middleware.duration" => finished - started,
+              },
+            )
           end
 
           # Every pair in the turn has a timed middle, so each one's duration
@@ -170,8 +202,8 @@ describe "brute/contrib/otel" do
             tool_calls: [{ id: "tc1", name: "echo", arguments: { "text" => "hi" } }])
         end
 
-        emit(Brute::Hooks::LLM_DURATION_EVENT, env) { :provider_call }
-        emit(Brute::Hooks::AFTER_LLM_EVENT, env)
+        env.emit(Brute::Hooks::LLM_DURATION_EVENT) { :provider_call }
+        env.emit(Brute::Hooks::LLM_END_EVENT)
         env
       end
     end)
@@ -190,7 +222,7 @@ describe "brute/contrib/otel" do
     span.events.map(&:first).should.include "tool_result"
     span.events.find { |name, _| name == "tool_call" }.last["tool.name"].should == "echo"
 
-    # :exit is timed, so each layer reports its own duration.
+    # :middleware_end is timed, so each layer reports its own duration.
     layer_event = span.events.find { |name, _| name == "middleware" }
     layer_event.last["middleware.name"].should == "Brute::Middleware::DefaultToolPipeline"
     layer_event.last["middleware.duration"].should.be >= 0

data/lib/brute/eval/case.rb

@@ -8,7 +8,12 @@ module Brute
     # The budget a case allows itself. Lenient on purpose: an agent that took
     # one search too many is worth knowing about, but it is not the same
     # fault as an agent that answered wrongly.
-    Budget = Data.define(:iterations, :tool_calls, :tokens, :seconds) do
+    Budget = Data.define(
+      :iterations,
+      :tool_calls,
+      :tokens,
+      :seconds,
+    ) do
       def initialize(iterations: 10, tool_calls: 8, tokens: 100_000, seconds: 180)
         super
       end
@@ -94,7 +99,7 @@ module Brute
             said_it(transcript),
             afforded(transcript),
             checked(transcript),
-          ].flatten.compact.uniq
+          ].flatten.compact.uniq,
         )
       end
 

data/lib/brute/eval/suite.rb

@@ -21,7 +21,12 @@ module Brute
     #
     # #run answers a process exit status, so an eval script ends `exit(...)`.
     class Suite
-      Result = Data.define(:kase, :run, :transcript, :verdict)
+      Result = Data.define(
+        :kase,
+        :run,
+        :transcript,
+        :verdict,
+      )
 
       def initialize(agent:, cases:, world: World.new, out: $stdout)
         @agent = agent
@@ -67,10 +72,10 @@ module Brute
           transcript.published = @world.published.dup
 
           Result.new(
-            kase: kase,
-            run: run,
+            kase:       kase,
+            run:        run,
             transcript: transcript,
-            verdict: kase.verdict(transcript)
+            verdict:    kase.verdict(transcript),
           )
         end
 
@@ -93,7 +98,7 @@ module Brute
             "  spent: #{transcript.iterations}/#{budget.iterations} iterations, " \
             "#{transcript.calls.length}/#{budget.tool_calls} calls, " \
             "#{transcript.tokens}/#{budget.tokens} tokens, " \
-            "#{transcript.seconds.round(1)}s"
+            "#{transcript.seconds.round(1)}s",
           )
           result.verdict.failures.each { |failure| @out.puts "  - #{failure}" }
           @out.puts "  said:"

data/lib/brute/eval/transcript.rb

@@ -34,12 +34,12 @@ module Brute
       end
 
       # The call env the tool pipeline hands its subscribers is one mutable
-      # hash per call, so the entry kept here at :before_tool carries the
+      # hash per call, so the entry kept here at :tool_start carries the
       # result the tool answered with by the time anyone reads it.
       def subscribe(agent)
         agent
-          .on(:before_tool) { |_env, call| @calls << call }
-          .on(:after_llm) { |env| account(env[:metadata][:last_llm_usage]) }
+          .on(:tool_start) { |_env, call| @calls << call }
+          .on(:llm_end) { |env| account(env[:metadata][:last_llm_usage]) }
           .on(:faraday_error) { |_env, error| @failures << describe(error) }
           .on(:open_router_server_error) { |_env, error| @failures << describe(error) }
           .on(:standard_error) { |_env, error| @failures << describe(error) }

data/lib/brute/eval/world.rb

@@ -38,12 +38,12 @@ module Brute
         kase.said
       end
 
-      # :before_tool is handed a mutable call env, and a :result set on it is
+      # :tool_start is handed a mutable call env, and a :result set on it is
       # answered without the tool ever running -- so a stub replaces the web,
       # the calendar or the shell without the agent being built differently.
       # A stub that answers to #call is handed the arguments.
       def stub(agent, stubs)
-        agent.on(:before_tool) do |_env, call|
+        agent.on(:tool_start) do |_env, call|
           canned = stubs[call[:name]]
 
           unless canned.nil?

data/lib/brute/eval.rb

@@ -38,7 +38,7 @@ module Brute
   # registry any other subscriber uses -- so the agent under evaluation is the
   # agent that ships: no eval-only middleware, no branch in agent.ru. The
   # model and the tool schemas are real; the tools themselves answer from the
-  # case's stubs, installed on :before_tool, which answers a call without
+  # case's stubs, installed on :tool_start, which answers a call without
   # executing it.
   #
   # Where a case wakes up is the World's business, and a deployment that

data/lib/brute/events/handler.rb

@@ -18,7 +18,9 @@ module Brute
       # thing, then call super (or don't, to swallow the event).
       def <<(event)
         tap do
-          @inner << event if @inner
+          if @inner
+            @inner << event
+          end
         end
       end
     end

data/lib/brute/events/prefixed_terminal_output.rb

@@ -29,7 +29,9 @@ module Brute
         data = event.to_h[:data]
 
         method = "on_#{type}"
-        send(method, data) if respond_to?(method, true)
+        if respond_to?(method, true)
+          send(method, data)
+        end
 
         super
       end

data/lib/brute/events/terminal_output_handler.rb

@@ -15,7 +15,7 @@ module Brute
         method = "on_#{type}"
 
         if respond_to?(method, true)
-          send(method, data) 
+          send(method, data)
         end
 
         super

data/lib/brute/hooks.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
+require "delegate"
+require "securerandom"
+
 require "brute"
 
 module Brute
@@ -9,87 +12,69 @@ module Brute
   #   Brute.agent
   #     .use(Brute::Middleware::MaxIterations)
   #     .run(->(env) { env[:messages].assistant("done") })
-  #     .on(:before_llm) { |env| ... }
-  #     .on(:approve_tool) { |_env, call| call[:name] != "exec" }
-  #
-  # Every subscriber is called with the turn env first, followed by whatever
-  # extras that event carries. A block that only wants the env can take one
-  # argument and ignore the rest.
-  #
-  # Emission points and payloads:
+  #     .on(:llm_start) { |env| ... }
+  #     .on(:tool_approve) { |_env, call| call[:name] != "exec" }
   #
-  #   :turn_start, :turn_end  → the turn env (AgentPipeline#start; turn_end
-  #                             fires from an ensure, so it also fires on
-  #                             error)
-  #   :turn_duration          → env, started, finished: the turn's work is
-  #                             this event's block
-  #   :middleware_added       → an empty env, then the middleware and every
-  #                             argument `use` was given (fires at build time,
-  #                             so only subscribers registered before the `use`
-  #                             see it)
-  #   :enter                  → env, the middleware instance, before the
-  #                             layer does anything
-  #   :duration               → env, started, finished, the middleware
-  #                             instance: the layer's work is this event's
-  #                             block, so it reports how long that took
-  #   :exit                   → env, the middleware instance, marking the
-  #                             layer done (from an ensure, so it fires on
-  #                             error too)
-  #   :before_llm, :after_llm → the turn env, around every LLM call
-  #   :llm_duration           → env, started, finished: the provider call is
-  #                             this event's block
-  #   :llm_failure            → the turn env, when the LLM call raises; the
-  #                             completion middleware then emits one of
-  #                             :faraday_error, :open_router_server_error or
-  #                             :standard_error with the exception as an extra
-  #   :compact_duration       → env, started, finished, the compactor: one
-  #                             strategy's attempt is this event's block, so
-  #                             the strategy that spends a model call is
-  #                             visible, and one that declined is still timed
-  #   :compacted              → env, {strategy:, before:, after:} — a
-  #                             compaction strategy rewrote env[:messages];
-  #                             what it replaced is already gone, so an
-  #                             application that keeps a transcript preserves
-  #                             it here
-  #   :before_tool            → env, call env {name:, arguments:, result:,
-  #                             denied:, events:, metadata:, turn_env:} —
-  #                             mutate :arguments to rewrite the call, or set
-  #                             :result to answer it without executing
-  #   :approve_tool           → env, call env — set :denied to true to deny
-  #                             the call, or to a String to deny it with that
-  #                             message
-  #   :tool_duration          → env, started, finished, call env: the tool's
-  #                             own execution is this event's block, so a
-  #                             skipped or denied call never fires it
-  #   :after_tool             → env, call env — mutate :result
-  #
-  # Subscribers run inline (tool events may fire from parallel threads).
-  # Exceptions propagate to the caller — layers that want fail-open semantics
-  # rescue in their own subscriber.
-  # Include this in anything that emits or subscribes and the event names are
-  # first class there: ENTER_EVENT rather than Brute::Hooks::ENTER_EVENT.
-  # The registry itself is Hooks::Registry, and Brute::Hooks.new builds one.
   module Hooks
     TURN_START_EVENT = :turn_start
     TURN_DURATION_EVENT = :turn_duration
     TURN_END_EVENT = :turn_end
+    TURN_FAILURE_EVENT = :turn_failure
     MIDDLEWARE_ADDED_EVENT = :middleware_added
-    ENTER_EVENT = :enter
-    DURATION_EVENT = :duration
-    EXIT_EVENT = :exit
-    BEFORE_LLM_EVENT = :before_llm
+    MIDDLEWARE_START_EVENT = :middleware_start
+    MIDDLEWARE_DURATION_EVENT = :middleware_duration
+    MIDDLEWARE_END_EVENT = :middleware_end
+    MIDDLEWARE_FAILURE_EVENT = :middleware_failure
+    LLM_START_EVENT = :llm_start
     LLM_DURATION_EVENT = :llm_duration
-    AFTER_LLM_EVENT = :after_llm
+    LLM_END_EVENT = :llm_end
     LLM_FAILURE_EVENT = :llm_failure
     FARADAY_ERROR_EVENT = :faraday_error
     OPEN_ROUTER_SERVER_ERROR_EVENT = :open_router_server_error
     STANDARD_ERROR_EVENT = :standard_error
+    COMPACT_START_EVENT = :compact_start
     COMPACT_DURATION_EVENT = :compact_duration
-    COMPACTED_EVENT = :compacted
-    BEFORE_TOOL_EVENT = :before_tool
-    APPROVE_TOOL_EVENT = :approve_tool
+    COMPACT_END_EVENT = :compact_end
+    COMPACT_FAILURE_EVENT = :compact_failure
+    CONTENT_EVENT = :content
+    REASONING_EVENT = :reasoning
+    TOOL_CALLS_EVENT = :tool_calls
+    TOOL_START_EVENT = :tool_start
+    TOOL_APPROVE_EVENT = :tool_approve
     TOOL_DURATION_EVENT = :tool_duration
-    AFTER_TOOL_EVENT = :after_tool
+    TOOL_END_EVENT = :tool_end
+    TOOL_FAILURE_EVENT = :tool_failure
+
+    # The env, wrapped, for as long as one call lasts. Everything emitted
+    # through it carries that call's id, and a call opened inside another
+    # delegates to it -- so the wrapper is the parent and unwrapping ends the
+    # call. It is still the env: SimpleDelegator forwards the rest.
+    class Trace < SimpleDelegator
+      attr_reader :id, :hooks
+
+      def initialize(env, hooks: nil, id: SecureRandom.uuid)
+        super(env)
+        if hooks
+          @hooks = hooks
+        elsif env.is_a?(Trace)
+          @hooks = env.hooks
+        end
+        @id = id
+      end
+
+      def current_trace = self
+
+      def emit(event, *extras, &work) = @hooks.emit(
+        event,
+        self,
+        *extras,
+        @id,
+        &work
+      )
+
+      def emit_trace(&block) = self.class.new(self).tap(&block).then { |trace| trace.__getobj__ }
+    end
+
 
     # The pub/sub registry a pipeline owns; `use` and `run` bind an emit to it.
     class Registry
@@ -102,40 +87,33 @@ module Brute
         self
       end
 
-      # Fire an event. An emitter announces; it answers nothing, and what a
-      # subscriber's block happens to evaluate to is not a signal. A layer
-      # that wants to take part in a turn does it by mutating what it was
-      # handed, never by returning something.
-      #
-      # Given a block, the event is timed instead: the block is the work, and
-      # subscribers fire once it is done, called as
-      # `|env, started, finished, *extras|` rather than `|env, *extras|`.
-      # Both stamps are monotonic, so a clock adjustment mid-turn cannot
-      # produce a negative duration.
-      #
       # The block is the work and nothing more: `emit` answers nothing in
       # either form, so a caller that needs the work's value takes it inside
       # the block.
       #
       #   result = nil
-      #   emit(DURATION_EVENT, env, self) { result = @app.call(env) }
-      #   # => .on(DURATION_EVENT) { |env, started, finished, layer| ... }
+      #   emit(MIDDLEWARE_DURATION_EVENT, env, self) { result = @app.call(env) }
+      #   # => .on(MIDDLEWARE_DURATION_EVENT) { |env, started, finished, layer| ... }
       #
       # Subscribers fire from an ensure, so work that raises is still timed
       # and still reported before the exception carries on up.
       def emit(event, env, *extras, &block)
-        unless block
+        if block
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            block.call
+          ensure
+            finished = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            @subscribers[event.to_sym].each { |subscriber| subscriber.call(
+              env,
+              started,
+              finished,
+              *extras,
+            ) }
+          end
+        else
           @subscribers[event.to_sym].each { |subscriber| subscriber.call(env, *extras) }
-          return nil
-        end
-
-        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-        begin
-          block.call
-        ensure
-          finished = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          @subscribers[event.to_sym].each { |subscriber| subscriber.call(env, started, finished, *extras) }
         end
 
         nil
@@ -143,8 +121,6 @@ module Brute
 
       def any?(event) = @subscribers[event.to_sym].any?
     end
-
-    def self.new(...) = Registry.new(...)
   end
 end
 
@@ -152,38 +128,38 @@ __END__
 
 describe "brute/hooks" do
   it "emits to subscribers in registration order" do
-    hooks = Brute::Hooks.new
+    hooks = Brute::Hooks::Registry.new
     seen = []
-    hooks.on(:before_llm) { |env| seen << "a#{env}" }
-    hooks.on(:before_llm) { |env| seen << "b#{env}" }
-    hooks.emit(:before_llm, 1)
+    hooks.on(:llm_start) { |env| seen << "a#{env}" }
+    hooks.on(:llm_start) { |env| seen << "b#{env}" }
+    hooks.emit(:llm_start, 1)
     seen.should == ["a1", "b1"]
   end
 
   it "answers nothing: a subscriber takes part by mutating, not by returning" do
-    hooks = Brute::Hooks.new
-    hooks.on(:approve_tool) { |_env, call| call[:denied] = true }
+    hooks = Brute::Hooks::Registry.new
+    hooks.on(:tool_approve) { |_env, call| call[:denied] = true }
 
     call = {}
-    hooks.emit(:approve_tool, {}, call).should.be.nil
+    hooks.emit(:tool_approve, {}, call).should.be.nil
     call[:denied].should.be.true
   end
 
   it "hands every subscriber the env first and the extras after" do
-    hooks = Brute::Hooks.new
+    hooks = Brute::Hooks::Registry.new
     seen = []
-    hooks.on(:after_tool) { |env, call| seen << [env, call] }
-    hooks.emit(:after_tool, :turn, :call)
+    hooks.on(:tool_end) { |env, call| seen << [env, call] }
+    hooks.emit(:tool_end, :turn, :call)
     seen.should == [[:turn, :call]]
   end
 
   it "times a block, hands subscribers start and finish, and reports even when the work raises" do
     seen = []
-    hooks = Brute::Hooks.new
-    hooks.on(:exit) { |env, started, finished, subject| seen << [env, started, finished, subject] }
+    hooks = Brute::Hooks::Registry.new
+    hooks.on(:middleware_end) { |env, started, finished, subject| seen << [env, started, finished, subject] }
 
     ran = nil
-    hooks.emit(:exit, :env, :layer) { ran = :work_result }.should.be.nil
+    hooks.emit(:middleware_end, :env, :layer) { ran = :work_result }.should.be.nil
     ran.should == :work_result
     seen.size.should == 1
     env, started, finished, subject = seen.first
@@ -192,19 +168,19 @@ describe "brute/hooks" do
     (finished - started).should.be >= 0
 
     # Work that raises is still timed and still reported.
-    should.raise(RuntimeError) { hooks.emit(:exit, :env, :layer) { raise "boom" } }
+    should.raise(RuntimeError) { hooks.emit(:middleware_end, :env, :layer) { raise "boom" } }
     seen.size.should == 2
 
     # Without a block it stays a point event: no timing argument.
     args = []
-    hooks2 = Brute::Hooks.new
-    hooks2.on(:exit) { |*received| args << received }
-    hooks2.emit(:exit, :env, :layer)
+    hooks2 = Brute::Hooks::Registry.new
+    hooks2.on(:middleware_end) { |*received| args << received }
+    hooks2.emit(:middleware_end, :env, :layer)
     args.should == [[:env, :layer]]
   end
 
   it "answers any? and stays chainable" do
-    hooks = Brute::Hooks.new
+    hooks = Brute::Hooks::Registry.new
     hooks.any?(:turn_start).should.be.false
     hooks.on(:turn_start) { nil }.should.equal?(hooks)
     hooks.any?(:turn_start).should.be.true

data/lib/brute/message_transport/anthropic.rb

@@ -55,7 +55,9 @@ module Brute
         when :assistant
           if message.tool_call?
             blocks = []
-            blocks << { type: "text", text: message.content } unless message.content.to_s.empty?
+            unless message.content.to_s.empty?
+              blocks << { type: "text", text: message.content }
+            end
             blocks += message.tool_calls.map { |tc| { type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments } }
             { role: "assistant", content: blocks }
           else
@@ -79,14 +81,22 @@ module Brute
 
           text = blocks.select { |b| b.type == :text }.map(&:text).join
           tool_calls = blocks.select { |b| b.type == :tool_use }.map do |b|
-            arguments = b.input.respond_to?(:to_h) ? b.input.to_h : b.input
+            if b.input.respond_to?(:to_h)
+              arguments = b.input.to_h
+            else
+              arguments = b.input
+            end
             Brute::ToolCall.new(id: b.id, name: b.name, arguments: arguments)
           end
 
+          if tool_calls.empty?
+            tool_calls = nil
+          end
+
           Brute::Message.new(
             role:       :assistant,
             content:    text,
-            tool_calls: (tool_calls unless tool_calls.empty?),
+            tool_calls: tool_calls,
           )
         end
     end