brute 5.1.0 → 6.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd46c42475fdbdaef5ec4f22cd15ff43d6d1bcf2dc2c37c744fb4c6dbbdc2289
-  data.tar.gz: 2ef42a57205047a0a0f0783a736a333ef7ee0d1fcbe583c0dbf7b97c7e2ba514
+  metadata.gz: 43f7aeaf57214c89c53faa449bc8f61e5be4cc03d193e9ea9595c09256a8c716
+  data.tar.gz: 38149dc7a1be90c6ecbe73a815afa4ac6e8bfbb3e7432bcf5666a7a054bfb158
 SHA512:
-  metadata.gz: cf83163546bc17c6ed562581067db5e6341088d2746fac3476ac56fcfeb2ac5230d3a7317a02c94a42a9b3ba6c43203578ecc995517d561741d788946b168064
-  data.tar.gz: 9f42fb22bc76a611043dadbcd2acb6f6b4862efda77e31af58c862d0ad1cb99587b46169055cd8ccd74936eeef8d1af2b42faa14b14fa6b6548c2ccf8b0dbdf0
+  metadata.gz: 01436d756163f52f35759f5ef3365c81493aceb50c74a692bc6bbb25a8122a10fe0b7d64be71b10c042cad71ae01eb1f3331abce19dfec97c854532ff67b61a4
+  data.tar.gz: c9a7efb6df3bbac0b816ead1dd10b54b57327ca5c1453000fcaf9a670a847b3fe0c1d1cf4ee783b9b13ea75385c92d70883e214db4de661bea3e0f3f3b577363

data/lib/brute/compaction/middleware/sliding_window.rb

@@ -33,7 +33,7 @@ module Brute
           # it anyway; declining here says why.
           if dropped.any? && !dropped.all? { |index| Brute::Compaction::Transcript.marked?(messages[index], strategy) }
             note = Brute::Message.new(
-              role: :user,
+              role:    :user,
               content: Brute::Compaction::Transcript.mark(strategy, format(NOTE, dropped.length)),
             )
             [*kept[...note_index], note, *kept[note_index..]]

data/lib/brute/compaction/middleware/strategy.rb

@@ -70,7 +70,6 @@ module Brute
               if after < before
                 env[:conversation] = rewritten
                 env[:applied] << { strategy: strategy, before: before, after: after }
-                env[:events] << { type: :compacted, data: env[:applied].last }
               end
             end
           end
@@ -113,7 +112,6 @@ describe "brute/compaction/middleware/strategy" do
     env[:conversation].map { |m| m.content[0, 1] }.should == ["a", "b"]
     asked.should == ["halves"]
     env[:applied].should == [{ strategy: "halves", before: 4_022, after: 2_011 }]
-    env[:events].should == [{ type: :compacted, data: { strategy: "halves", before: 4_022, after: 2_011 } }]
 
     # A rewrite that saved nothing is refused and the ladder carries on past
     # it, so the strategy itself never has to check.

data/lib/brute/compaction/summarize.rb

@@ -113,22 +113,21 @@ module Brute
         end
 
         def summarise(env, indices)
-          asked = { messages: prompt(env[:conversation], indices), metadata: {}, events: env[:events] }
+          asked = { messages: prompt(env[:conversation], indices), metadata: {} }
           @generator.call(asked)
           answer = asked[:messages].last&.content.to_s.strip
 
           unless answer.empty?
             answer
           end
-        rescue => error
-          env[:events] << { type: :error, data: { error: error, message: error.message } }
+        rescue
           nil
         end
 
         def swap(env, indices, text)
           before = tokens(env[:conversation])
           summary = Brute::Message.new(
-            role: :user,
+            role:    :user,
             content: Brute::Compaction::Transcript.mark(STRATEGY, text),
           )
           compacted = splice(env[:conversation], indices, summary)
@@ -137,7 +136,6 @@ module Brute
           if after < before
             env[:conversation] = compacted
             env[:applied] << { strategy: STRATEGY, before: before, after: after }
-            env[:events] << { type: :compacted, data: env[:applied].last }
             true
           else
             false
@@ -177,27 +175,34 @@ module Brute
           conversation = env[:conversation]
           system_end = Brute::Compaction::Transcript.system_end(conversation)
           task = Brute::Compaction::Transcript.task_index(conversation)
+          target = env[:target]
 
-          turns(conversation, system_end, task, env[:target]) ||
-            history_summaries(conversation, system_end, task || system_end, env[:target]) ||
-            steps(conversation, env[:target]) ||
-            task_summaries(conversation, task, env[:target])
+          # Everything before the current task: what tiers 1 and 2 are allowed
+          # to give up, and the only thing either of them needs to be told.
+          history = system_end...(task || system_end)
+
+          t = turns(conversation, history, target)
+          h = history_summaries(conversation, history, target)
+          s = steps(conversation, target)
+          ts = task_summaries(conversation, task, target)
+
+          t || h || s || ts
         end
 
         # Tier 1. Whole historical turns, oldest first.
-        def turns(conversation, system_end, task, target)
+        def turns(conversation, history, target)
           groups = Brute::Compaction::Transcript.turns(
             conversation,
-            from: system_end,
-            to: task || system_end,
+            from: history.begin,
+            to:   history.end,
           ).map(&:to_a)
 
           enough(conversation, groups, target)
         end
 
         # Tier 2. History is nothing but summaries, so combine the oldest.
-        def history_summaries(conversation, system_end, history_end, target)
-          combine(conversation, summaries(conversation, system_end, history_end), target)
+        def history_summaries(conversation, history, target)
+          combine(conversation, summaries(conversation, history), target)
         end
 
         # Tier 3. The current task's own oldest steps, keeping the newest.
@@ -212,12 +217,17 @@ module Brute
 
         # Tier 4. No step may go, so combine the task's own summaries.
         def task_summaries(conversation, task, target)
-          start = task.nil? ? 0 : task + 1
-          combine(conversation, summaries(conversation, start, conversation.length), target)
+          if task.nil?
+            start = 0
+          else
+            start = task + 1
+          end
+
+          combine(conversation, summaries(conversation, start...conversation.length), target)
         end
 
-        def summaries(conversation, from, to)
-          (from...to).select do |index|
+        def summaries(conversation, range)
+          range.select do |index|
             Brute::Compaction::Transcript.marked?(conversation[index], STRATEGY)
           end
         end
@@ -326,11 +336,10 @@ describe "brute/compaction/summarize" do
     windy = ->(env) { env[:messages] << said(:assistant, "w" * 90_000) }
     summarised(history, 3_000, windy, keep_steps: 1)[:applied].should == []
 
-    # A generator that raises ends the loop rather than the turn, and says so.
-    env = { conversation: history, target: 3_000, applied: [], events: [] }
+    # A generator that raises ends the loop rather than the turn.
+    env = { conversation: history, target: 3_000, applied: [] }
     Brute::Compaction::Summarize.new(->(_e) { raise IOError, "the summariser is down" }).call(env)
     env[:applied].should == []
-    env[:events].map { |e| [e[:type], e[:data][:message]] }.should == [[:error, "the summariser is down"]]
 
     # And one that works after the tiers are exhausted still stops.
     once = ->(e) { e[:messages] << said(:assistant, "small") }

data/lib/brute/completion/lang_chain.rb

@@ -42,31 +42,32 @@ module Brute
       end
 
       def call(env)
-        emit(BEFORE_LLM_EVENT, env)
+        env.emit_trace do |env|
+          env.emit(LLM_START_EVENT)
 
-        response = nil
-        emit(LLM_DURATION_EVENT, env) { response = @llm.chat(**params(env)) }
+          response = nil
+          env.emit(LLM_DURATION_EVENT) { response = @llm.chat(**params(env)) }
 
-        if (usage = Brute::MessageTransport::LangChain.usage_metrics(response))
-          (env[:metadata] ||= {})[:last_llm_usage] = usage
-        end
+          if (usage = Brute::MessageTransport::LangChain.usage_metrics(response))
+            (env[:metadata] ||= {})[:last_llm_usage] = usage
+          end
 
-        # langchainrb speaks the OpenAI-style wire format both ways.
-        Brute::MessageTransport::LangChain.wrap_each(reply(response)) do |message|
-          env[:messages] << message
-        end
+          # langchainrb speaks the OpenAI-style wire format both ways.
+          Brute::MessageTransport::LangChain.wrap_each(reply(response)) do |message|
+            env[:messages] << message
+          end
 
-        emit(AFTER_LLM_EVENT, env)
-        env
-      rescue => error
-        emit(LLM_FAILURE_EVENT, env)
+          env.emit(LLM_END_EVENT)
+        rescue => error
+          env.emit(LLM_FAILURE_EVENT)
 
-        if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
-          emit(FARADAY_ERROR_EVENT, env, error)
-        else
-          emit(STANDARD_ERROR_EVENT, env, error)
-        end
+          if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
+            env.emit(FARADAY_ERROR_EVENT, error)
+          else
+            env.emit(STANDARD_ERROR_EVENT, error)
+          end
 
+        end
         env
       end
 
@@ -75,18 +76,20 @@ module Brute
         attr_reader :options
 
         def params(env)
-          params = {
+          {
             messages:    Brute::MessageTransport::LangChain.dump_all(env[:messages]),
             temperature: temperature(env),
-          }
-
-          tools = tool_definitions(env)
-          params[:tools] = tools if tools.any?
-
-          model = option(env, :model)
-          params[:model] = model if model
-
-          params
+          }.tap do |params|
+            tools = tool_definitions(env)
+            if tools.any?
+              params[:tools] = tools
+            end
+
+            model = option(env, :model)
+            if model
+              params[:model] = model
+            end
+          end
         end
 
         def reply(response)
@@ -143,8 +146,8 @@ describe "brute/completion/lang_chain" do
     seen = []
     pipeline = Brute::Turn::Pipeline.new
     pipeline.run Brute::Completion::LangChain.new(llm: llm, model: "gpt-4o-mini")
-    pipeline.on(Brute::Hooks::BEFORE_LLM_EVENT) { |_env| seen << :before }
-    pipeline.on(Brute::Hooks::AFTER_LLM_EVENT) { |_env| seen << :after }
+    pipeline.on(Brute::Hooks::LLM_START_EVENT) { |_env| seen << :before }
+    pipeline.on(Brute::Hooks::LLM_END_EVENT) { |_env| seen << :after }
     pipeline.call(env)
 
     env[:messages].last.role.should == :assistant

data/lib/brute/completion/llmrb.rb

@@ -44,34 +44,35 @@ module Brute
       end
 
       def call(env)
-        emit(BEFORE_LLM_EVENT, env)
+        env.emit_trace do |env|
+          env.emit(LLM_START_EVENT)
 
-        # llm.rb takes the last message as the prompt and the rest as history.
-        messages = Brute::MessageTransport::LLM.dump_all(env[:messages])
-        prompt = messages.pop
+          # llm.rb takes the last message as the prompt and the rest as history.
+          messages = Brute::MessageTransport::LLM.dump_all(env[:messages])
+          prompt = messages.pop
 
-        response = nil
-        emit(LLM_DURATION_EVENT, env) { response = client(env).complete(prompt, **params(env, messages)) }
+          response = nil
+          env.emit(LLM_DURATION_EVENT) { response = client(env).complete(prompt, **params(env, messages)) }
 
-        if (usage = Brute::MessageTransport::LLM.usage_metrics(response))
-          (env[:metadata] ||= {})[:last_llm_usage] = usage
-        end
+          if (usage = Brute::MessageTransport::LLM.usage_metrics(response))
+            (env[:metadata] ||= {})[:last_llm_usage] = usage
+          end
 
-        Brute::MessageTransport::LLM.wrap_each(response) do |message|
-          env[:messages] << message
-        end
+          Brute::MessageTransport::LLM.wrap_each(response) do |message|
+            env[:messages] << message
+          end
 
-        emit(AFTER_LLM_EVENT, env)
-        env
-      rescue => error
-        emit(LLM_FAILURE_EVENT, env)
+          env.emit(LLM_END_EVENT)
+        rescue => error
+          env.emit(LLM_FAILURE_EVENT)
 
-        if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
-          emit(FARADAY_ERROR_EVENT, env, error)
-        else
-          emit(STANDARD_ERROR_EVENT, env, error)
-        end
+          if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
+            env.emit(FARADAY_ERROR_EVENT, error)
+          else
+            env.emit(STANDARD_ERROR_EVENT, error)
+          end
 
+        end
         env
       end
 
@@ -80,16 +81,17 @@ module Brute
         attr_reader :options
 
         def params(env, history)
-          params = {
+          {
             role:        nil,
             model:       option(env, :model),
             messages:    history,
             temperature: temperature(env),
-          }.compact
-
-          functions = functions(env)
-          params[:tools] = functions if functions.any?
-          params
+          }.compact.tap do |params|
+            functions = functions(env)
+            if functions.any?
+              params[:tools] = functions
+            end
+          end
         end
 
         def client(env)
@@ -154,8 +156,8 @@ describe "brute/completion/llmrb" do
     seen = []
     pipeline = Brute::Turn::Pipeline.new
     pipeline.run Brute::Completion::LLMrb.new(client: client, temperature: 0.1)
-    pipeline.on(Brute::Hooks::BEFORE_LLM_EVENT) { |_env| seen << :before }
-    pipeline.on(Brute::Hooks::AFTER_LLM_EVENT) { |_env| seen << :after }
+    pipeline.on(Brute::Hooks::LLM_START_EVENT) { |_env| seen << :before }
+    pipeline.on(Brute::Hooks::LLM_END_EVENT) { |_env| seen << :after }
     pipeline.call(env)
 
     env[:messages].last.role.should == :assistant

data/lib/brute/completion/open_router.rb

@@ -43,52 +43,53 @@ module Brute
       end
 
       def call(env)
-        emit(BEFORE_LLM_EVENT, env)
-
-        messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages])
-
-        ::OpenRouter::Client.new(**@config).then do |client|
-          response = nil
-          emit(LLM_DURATION_EVENT, env) { response = client.complete(messages, options(env)) }
-
-          response.then do |response|
-
-            # Expose the provider's usage for downstream accounting
-            # (goal budgets, autonomous limits, compaction thresholds, usage
-            # attribution) — additive metadata only, normalised so a reader
-            # does not have to know which provider answered.
-            if (usage = Brute::MessageTransport::OpenRouter.usage_metrics(response))
-              (env[:metadata] ||= {})[:last_llm_usage] = usage
-            end
-
-            # OpenRouter in fact only returns a single message...
-            # https://github.com/estiens/open_router_enhanced/blob/main/lib/open_router/response.rb
-            Brute::MessageTransport::OpenRouter.wrap_each(response) do |message|
-              env[:messages] << message
+        env.emit_trace do |env|
+          env.emit(LLM_START_EVENT)
+
+          messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages])
+
+          ::OpenRouter::Client.new(**@config).then do |client|
+            response = nil
+            env.emit(LLM_DURATION_EVENT) { response = client.complete(messages, options(env)) }
+
+            response.then do |response|
+
+              # Expose the provider's usage for downstream accounting
+              # (goal budgets, autonomous limits, compaction thresholds, usage
+              # attribution) — additive metadata only, normalised so a reader
+              # does not have to know which provider answered.
+              if (usage = Brute::MessageTransport::OpenRouter.usage_metrics(response))
+                (env[:metadata] ||= {})[:last_llm_usage] = usage
+              end
+
+              # OpenRouter in fact only returns a single message...
+              # https://github.com/estiens/open_router_enhanced/blob/main/lib/open_router/response.rb
+              Brute::MessageTransport::OpenRouter.wrap_each(response) do |message|
+                env[:messages] << message
+              end
             end
           end
-        end
 
-        emit(AFTER_LLM_EVENT, env)
-        env
-      # A provider call that raises is reported through the hooks rather than
-      # up the stack: :llm_failure with the turn env, then one hook naming the
-      # kind of failure. The classes are looked up defensively — the provider
-      # gem is only a dependency of the app that uses this middleware.
-      rescue => error
-        emit(LLM_FAILURE_EVENT, env)
+          env.emit(LLM_END_EVENT)
+        # A provider call that raises is reported through the hooks rather than
+        # up the stack: :llm_failure with the turn env, then one hook naming the
+        # kind of failure. The classes are looked up defensively — the provider
+        # gem is only a dependency of the app that uses this middleware.
+        rescue => error
+          env.emit(LLM_FAILURE_EVENT)
 
-        if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
-          emit(FARADAY_ERROR_EVENT, env, error)
+          if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
+            env.emit(FARADAY_ERROR_EVENT, error)
 
-        elsif defined?(::OpenRouter::ServerError) && error.is_a?(::OpenRouter::ServerError)
-          emit(OPEN_ROUTER_SERVER_ERROR_EVENT, env, error)
+          elsif defined?(::OpenRouter::ServerError) && error.is_a?(::OpenRouter::ServerError)
+            env.emit(OPEN_ROUTER_SERVER_ERROR_EVENT, error)
 
-        else
-          emit(STANDARD_ERROR_EVENT, env, error)
+          else
+            env.emit(STANDARD_ERROR_EVENT, error)
 
-        end
+          end
 
+        end
         env
       end
 
@@ -100,7 +101,9 @@ module Brute
 
           unless @options.tools?
             tools = tool_definitions(env)
-            overrides[:tools] = tools if tools.any?
+            if tools.any?
+              overrides[:tools] = tools
+            end
           end
 
           if !@model_given && (model = env[:model])
@@ -266,7 +269,7 @@ describe "brute/completion/open_router" do
       env[:messages].user("hi")
       pipeline = Brute::Turn::Pipeline.new
       pipeline.run Brute::Completion::OpenRouter.new
-      %i[llm_failure standard_error after_llm].each do |event|
+      %i[llm_failure standard_error llm_end].each do |event|
         pipeline.on(event) { |hook_env, extra| seen << [event, hook_env, extra] }
       end
       returned = pipeline.call(env)

data/lib/brute/completion/ruby_llm.rb

@@ -59,35 +59,36 @@ module Brute
       end
 
       def call(env)
-        emit(BEFORE_LLM_EVENT, env)
+        env.emit_trace do |env|
+          env.emit(LLM_START_EVENT)
 
-        messages = Brute::MessageTransport::RubyLLM.dump_all(env[:messages])
-        response = nil
-        emit(LLM_DURATION_EVENT, env) { response = complete(env, messages) }
+          messages = Brute::MessageTransport::RubyLLM.dump_all(env[:messages])
+          response = nil
+          env.emit(LLM_DURATION_EVENT) { response = complete(env, messages) }
 
-        unless response.nil?
-          if (usage = Brute::MessageTransport::RubyLLM.usage_metrics(response))
-            (env[:metadata] ||= {})[:last_llm_usage] = usage
+          unless response.nil?
+            if (usage = Brute::MessageTransport::RubyLLM.usage_metrics(response))
+              (env[:metadata] ||= {})[:last_llm_usage] = usage
+            end
+
+            Brute::MessageTransport::RubyLLM.wrap_each(response) do |message|
+              env[:messages] << message
+            end
           end
 
-          Brute::MessageTransport::RubyLLM.wrap_each(response) do |message|
-            env[:messages] << message
+          env.emit(LLM_END_EVENT)
+        # A provider call that raises is reported through the hooks rather than
+        # up the stack, the same way the OpenRouter completion does it.
+        rescue => error
+          env.emit(LLM_FAILURE_EVENT)
+
+          if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
+            env.emit(FARADAY_ERROR_EVENT, error)
+          else
+            env.emit(STANDARD_ERROR_EVENT, error)
           end
-        end
 
-        emit(AFTER_LLM_EVENT, env)
-        env
-      # A provider call that raises is reported through the hooks rather than
-      # up the stack, the same way the OpenRouter completion does it.
-      rescue => error
-        emit(LLM_FAILURE_EVENT, env)
-
-        if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
-          emit(FARADAY_ERROR_EVENT, env, error)
-        else
-          emit(STANDARD_ERROR_EVENT, env, error)
         end
-
         env
       end
 
@@ -104,7 +105,7 @@ module Brute
 
           provider_client = client(option(env, :provider))
 
-          # Streaming reports through env[:events] chunk by chunk; the final
+          # Streaming reports through :content and :reasoning chunk by chunk; the final
           # message still comes back for the log.
           if streaming?(env)
             provider_client.complete(messages, **kwargs) do |chunk|
@@ -117,11 +118,11 @@ module Brute
 
         def stream(env, chunk)
           if chunk.content && !chunk.content.to_s.empty?
-            env[:events] << { type: :content, data: chunk.content.to_s }
+            env.emit(CONTENT_EVENT, chunk.content.to_s)
           end
 
           if chunk.respond_to?(:thinking) && chunk.thinking.respond_to?(:text) && chunk.thinking&.text
-            env[:events] << { type: :reasoning, data: chunk.thinking.text }
+            env.emit(REASONING_EVENT, chunk.thinking.text)
           end
         end
 
@@ -214,8 +215,8 @@ describe "brute/completion/ruby_llm" do
 
     seen = []
     pipeline = running.call(Brute::Completion::RubyLLM.new(client: client, model: "use-this-model", temperature: 0.1))
-    pipeline.on(Brute::Hooks::BEFORE_LLM_EVENT) { |_env| seen << :before }
-    pipeline.on(Brute::Hooks::AFTER_LLM_EVENT) { |_env| seen << :after }
+    pipeline.on(Brute::Hooks::LLM_START_EVENT) { |_env| seen << :before }
+    pipeline.on(Brute::Hooks::LLM_END_EVENT) { |_env| seen << :after }
     pipeline.call(env)
 
     env[:messages].last.role.should == :assistant