brute 4.2.0 → 4.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6016495cc66cb0d8c5b7b33aaef14eee694960355bb2d772c2d75b1aaacca844
-  data.tar.gz: 137446fd33a37736993e2d067d75169d8ca1ce83c109511054b73e768550fda5
+  metadata.gz: f8264f0e2d23e001a3c980d3edd0f88ac3ceb8a3f167359c56391e3fe9702e59
+  data.tar.gz: 7439466f57b0f3e18aae290a723f8cb4077970b200f1a8e0f7970fd7d863aee6
 SHA512:
-  metadata.gz: 4098f01a58d7d6946fb4f362aab7d37db86cb1f6e77def51f96e08b86eddbaa8c5462e8a613d9e74ff84731baf5ed65076abd010c2ab854b5e838279b3801ee3
-  data.tar.gz: 25c4986d4beed8103eb6c0f527ad737b98de3f7c3d1e562c83f956afcc3b3267eb5c6cb669ac488cf9ffdf97c6a446888f9363a2d01bd6f3913701d7cc46c313
+  metadata.gz: 5fa71cbfe00b6069e2bdb90872cff9fe2f88eb2f48c7ff614feb59ead8f03890739c4772c863b09edf27fd7c2c122ac486fc5c3d84f582f477527f5f69d2dee4
+  data.tar.gz: 866794dc4f87f5433508b1e883db27788b00bb57157211ea2942fe64ccaa46969c3cfdd36fe917b9717fe7bdc385f4fd9881b1a5ce47c9763e859d7e00fbf356

data/lib/brute/completion/open_router.rb

@@ -48,6 +48,25 @@ module Brute
         end
 
         env[:hooks]&.emit(:after_llm, 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
+        env[:hooks]&.emit(:llm_failure, env)
+
+        if defined?(::Faraday::Error) && error.is_a?(::Faraday::Error)
+          env[:hooks]&.emit(:faraday_error, error)
+
+        elsif defined?(::OpenRouter::ServerError) && error.is_a?(::OpenRouter::ServerError)
+          env[:hooks]&.emit(:open_router_server_error, error)
+
+        else
+          env[:hooks]&.emit(:standard_error, error)
+
+        end
+
         env
       end
     end
@@ -106,6 +125,33 @@ describe "brute/completion/open_router" do
     env.key?(:metadata).should.be.false
   end
 
+  it "reports a failed provider call through the hooks instead of raising" do
+    seen = []
+    hooks = Brute::Hooks.new
+    %i[llm_failure standard_error after_llm].each do |event|
+      hooks.on(event) { |payload| seen << [event, payload] }
+    end
+
+    boom = RuntimeError.new("no route to host")
+    fake_client = Object.new
+    fake_client.define_singleton_method(:complete) { |_messages, _options| raise boom }
+    original = OpenRouter::Client.method(:new)
+    OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
+
+    begin
+      env = { messages: Brute.log, hooks: hooks }
+      env[:messages].user("hi")
+      returned = Brute::Completion::OpenRouter.new(->(e) { e }).call(env)
+
+      returned.should.be.identical_to env
+      seen.map(&:first).should == [:llm_failure, :standard_error]
+      seen.first.last.should.be.identical_to env
+      seen.last.last.should.be.identical_to boom
+    ensure
+      OpenRouter::Client.define_singleton_method(:new, original)
+    end
+  end
+
   it "still answers to the deprecated Middleware::OpenRouter::Completion name" do
     deprecated = Brute::Middleware::OpenRouter::Completion.new(->(e) { e })
     deprecated.should.be.kind_of?(Brute::Completion::OpenRouter)

data/lib/brute/hooks.rb

@@ -17,6 +17,10 @@ module Brute
   #   :turn_start, :turn_end  → the turn env (AgentPipeline#start; turn_end
   #                             fires from an ensure, so it also fires on error)
   #   :before_llm, :after_llm → the turn env, around every LLM call
+  #   :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 itself
   #   :before_tool            → call env {name:, arguments:, result:, events:,
   #                             metadata:, turn_env:} — mutate :arguments to
   #                             rewrite the call, or set :result (or return a
@@ -29,7 +33,9 @@ module Brute
   # Exceptions propagate to the caller — layers that want fail-open semantics
   # rescue in their own subscriber.
   class Hooks
-    EVENTS = %i[turn_start turn_end before_llm after_llm before_tool approve_tool after_tool].freeze
+    EVENTS = %i[turn_start turn_end before_llm after_llm llm_failure faraday_error
+                open_router_server_error standard_error before_tool approve_tool
+                after_tool].freeze
 
     def initialize
       @subscribers = Hash.new { |hash, key| hash[key] = [] }

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

@@ -71,30 +71,24 @@ describe "brute/middleware/002_session_log" do
     Dir.mktmpdir do |dir|
       path = File.join(dir, "session.jsonl")
 
-      # Turn 1: no file yet; terminal appends an assistant reply.
-      turn = ->(env) { env[:messages].assistant("first reply") }
-      Brute::Middleware::SessionLog.new(turn, path: path).call(
-        { messages: Brute.log.tap { |l| l.user("hi") } }
-      )
+      Brute::Middleware::SessionLog.new(->(e) { e[:messages].assistant("first reply") }, path: path)
+        .call({ messages: Brute.log.tap { |l| l.user("hi") } })
 
-      File.exist?(path).should.be.true
-
-      # Turn 2: fresh log with a new user message; history is prepended.
       env = { messages: Brute.log.tap { |l| l.user("again") } }
       Brute::Middleware::SessionLog.new(->(e) { }, path: path).call(env)
 
+      File.exist?(path).should.be.true
       env[:messages].map(&:content).should == ["hi", "first reply", "again"]
     end
   end
 
   it "does not persist the system message" do
     Dir.mktmpdir do |dir|
-      path = File.join(dir, "s.jsonl")
-      env = { messages: Brute.log.tap { |l| l.system("secret prompt"); l.user("hi") } }
-      Brute::Middleware::SessionLog.new(->(e) { }, path: path).call(env)
+      path = File.join(dir, "session.jsonl")
+      Brute::Middleware::SessionLog.new(->(e) { }, path: path)
+        .call({ messages: Brute.log.tap { |l| l.system("secret prompt"); l.user("hi") } })
 
-      reloaded = File.readlines(path).map(&:strip).reject(&:empty?)
-      reloaded.any? { |line| line.include?("secret prompt") }.should.be.false
+      File.read(path).should.not.match(/secret prompt/)
     end
   end
 end

data/lib/brute/middleware/004_summarize.rb

@@ -51,91 +51,25 @@ __END__
 describe "brute/middleware/004_summarize" do
   require "brute/messages"
 
-  it "produces a final assistant message after tool loop" do
-    call_count = 0
-
-    # Fake inner app: first call simulates a tool loop ending with a tool message,
-    # second call (summary) produces an assistant message.
+  it "reruns the stack tool-free with a summary prompt, then restores the tools" do
+    seen = []
     inner = ->(env) do
-      call_count += 1
-      if call_count == 1
-        env[:messages] << Brute::Message.new(role: :tool, content: "some result", tool_call_id: "tc1")
-      else
-        env[:messages] << Brute::Message.new(role: :assistant, content: "Here is my complete summary.")
-      end
-    end
-
-    mw = Brute::Middleware::Summarize.new(inner)
-    session = Brute.log
-    session.user("explore the codebase")
-    env = { messages: session, tools: [:some_tool], current_iteration: 5 }
-    mw.call(env)
-
-    env[:messages].last.role.should == :assistant
-    env[:messages].last.content.should =~ /summary/i
-  end
-
-  it "restores tools after summary call" do
-    inner = ->(env) {
-      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
-    }
-
-    mw = Brute::Middleware::Summarize.new(inner)
-    tools = [:read, :search]
-    env = { messages: Brute.log, tools: tools.dup, current_iteration: 1 }
-    env[:messages].user("hi")
-    mw.call(env)
-
-    env[:tools].should == tools
-  end
-
-  it "resets current_iteration for the summary call" do
-    captured_iteration = nil
-    inner = ->(env) {
-      captured_iteration = env[:current_iteration]
-      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
-    }
-
-    mw = Brute::Middleware::Summarize.new(inner)
-    env = { messages: Brute.log, tools: [], current_iteration: 99 }
-    env[:messages].user("hi")
-    mw.call(env)
-
-    # The second call (summary) should have iteration reset to 1
-    captured_iteration.should == 1
-  end
-
-  it "injects a summary prompt message" do
-    messages_at_second_call = nil
-    call_count = 0
-    inner = ->(env) {
-      call_count += 1
-      messages_at_second_call = env[:messages].map(&:content) if call_count == 2
+      seen << [env[:tools], env[:current_iteration], env[:messages].last.content]
       env[:messages] << Brute::Message.new(role: :assistant, content: "done")
-    }
-
-    mw = Brute::Middleware::Summarize.new(inner)
-    env = { messages: Brute.log, tools: [], current_iteration: 1 }
-    env[:messages].user("hi")
-    mw.call(env)
-
-    messages_at_second_call.last.should =~ /findings/i
-  end
+    end
 
-  it "accepts a custom prompt" do
-    messages_at_second_call = nil
-    call_count = 0
-    inner = ->(env) {
-      call_count += 1
-      messages_at_second_call = env[:messages].map(&:content) if call_count == 2
-      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
-    }
+    env = { messages: Brute.log.tap { |l| l.user("explore the codebase") },
+            tools: [:read, :search], current_iteration: 5 }
+    Brute::Middleware::Summarize.new(inner).call(env)
 
-    mw = Brute::Middleware::Summarize.new(inner, prompt: "Give me the TL;DR.")
-    env = { messages: Brute.log, tools: [], current_iteration: 1 }
-    env[:messages].user("hi")
-    mw.call(env)
+    seen.should == [
+      [[:read, :search], 5, "explore the codebase"],
+      [[], 1, Brute::Middleware::Summarize::DEFAULT_PROMPT],
+    ]
+    env[:tools].should == [:read, :search]
 
-    messages_at_second_call.last.should == "Give me the TL;DR."
+    seen.clear
+    Brute::Middleware::Summarize.new(inner, prompt: "Give me the TL;DR.").call(env)
+    seen.last.last.should == "Give me the TL;DR."
   end
 end

data/lib/brute/middleware/006_loop.rb

@@ -71,6 +71,24 @@ module Brute
           super(app, CONDITION)
         end
       end
+
+      # Keeps the turn alive while background jobs are running. Sit it
+      # OUTSIDE the tool loop: the inner loop ends when the model answers
+      # with text, and this one sends control back in for another pass while
+      # jobs are still running — which is how a finished job gets reported.
+      # Whatever spawns the jobs (say, a middleware running a subagent in
+      # the background) keeps env[:background_jobs] current.
+      #
+      #   use Brute::Middleware::Loop::BackgroundJobs
+      #   use Brute::Middleware::Loop::ToolResult
+      #
+      class BackgroundJobs < Loop
+        CONDITION = ->(env) { env[:background_jobs] }
+
+        def initialize(app)
+          super(app, CONDITION)
+        end
+      end
     end
   end
 end
@@ -80,90 +98,54 @@ __END__
 describe "brute/middleware/006_loop" do
   require "brute/messages"
 
-  it "runs the inner app once when the condition is immediately false" do
-    calls = 0
-    mw = Brute::Middleware::Loop.new(->(_env) { calls += 1 }, ->(_env) { false })
-    mw.call({})
-    calls.should == 1
-  end
-
-  it "loops while the condition is truthy" do
-    calls = 0
-    mw = Brute::Middleware::Loop.new(->(_env) { calls += 1 }, ->(_env) { calls < 3 })
-    mw.call({})
-    calls.should == 3
-  end
-
-  it "accepts a block condition and passes env to it" do
-    seen = []
-    mw = Brute::Middleware::Loop.new(->(env) { env[:n] += 1 }) { |env| seen << env[:n]; env[:n] < 2 }
+  it "runs the app until the condition turns false, passing it env" do
+    passes = []
     env = { n: 0 }
-    mw.call(env)
-    env[:n].should == 2
-    seen.should == [1, 2]
-  end
+    returned = Brute::Middleware::Loop.new(->(e) { e[:n] += 1; passes << e[:n]; e }) { |e| e[:n] < 3 }.call(env)
 
-  it "returns env" do
-    env = { a: 1 }
-    Brute::Middleware::Loop.new(->(_e) {}, ->(_e) { false }).call(env).should == env
-  end
+    passes.should == [1, 2, 3]
+    returned.should.be.identical_to env
 
-  it "raises without a proc or block" do
     lambda { Brute::Middleware::Loop.new(->(_e) {}) }.should.raise(ArgumentError)
   end
 
   # --- Loop::ToolResult (reimplements the old ToolResultLoop) ---
 
-  it "ToolResult loops until the last message is not a tool result" do
-    call_count = 0
+  it "ToolResult reruns while the last message is a tool result, unless should_exit" do
+    calls = []
     inner = ->(env) do
-      call_count += 1
-      if call_count == 1
-        env[:messages] << Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
-      else
-        env[:messages] << Brute::Message.new(role: :assistant, content: "done")
-      end
+      calls << env[:current_iteration]
+      env[:messages] << Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc#{calls.size}")
+      env[:should_exit] = { reason: "max" } if calls.size >= 2
     end
 
-    mw = Brute::Middleware::Loop::ToolResult.new(inner)
-    env = { messages: Brute.log, current_iteration: 1 }
-    env[:messages].user("hi")
-    mw.call(env)
+    env = { messages: Brute.log.tap { |l| l.user("hi") }, current_iteration: 1 }
+    Brute::Middleware::Loop::ToolResult.new(inner).call(env)
+    calls.should == [1, 2]
 
-    call_count.should == 2
-    env[:current_iteration].should == 2
-    env[:messages].last.role.should == :assistant
-  end
-
-  it "ToolResult stops when should_exit is set" do
-    call_count = 0
-    inner = ->(env) do
-      call_count += 1
-      env[:messages] << Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc#{call_count}")
-      env[:should_exit] = { reason: "max" } if call_count >= 2
+    calls.clear
+    text_only = ->(env) do
+      calls << env[:current_iteration]
+      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
     end
-
-    mw = Brute::Middleware::Loop::ToolResult.new(inner)
-    env = { messages: Brute.log, current_iteration: 1 }
-    env[:messages].user("hi")
-    mw.call(env)
-
-    call_count.should == 2
+    env = { messages: Brute.log.tap { |l| l.user("hi") }, current_iteration: 1 }
+    Brute::Middleware::Loop::ToolResult.new(text_only).call(env)
+    calls.should == [1]
+    env[:current_iteration].should == 1
   end
 
-  it "ToolResult does not loop when last message is assistant" do
-    call_count = 0
-    inner = ->(env) do
-      call_count += 1
-      env[:messages] << Brute::Message.new(role: :assistant, content: "hello")
-    end
+  # --- Loop::BackgroundJobs ---
 
-    mw = Brute::Middleware::Loop::ToolResult.new(inner)
-    env = { messages: Brute.log, current_iteration: 1 }
-    env[:messages].user("hi")
-    mw.call(env)
+  it "BackgroundJobs reruns while jobs are running" do
+    seen = []
+    inner = ->(env) { seen << env[:background_jobs]; env[:background_jobs] = seen.size < 3 }
 
-    call_count.should == 1
-    env[:current_iteration].should == 1
+    Brute::Middleware::Loop::BackgroundJobs.new(inner).call({})
+    seen.should == [nil, true, true]
+
+    seen.clear
+    Brute::Middleware::Loop::BackgroundJobs.new(->(e) { seen << e[:background_jobs]; e[:background_jobs] = false })
+      .call({ background_jobs: true })
+    seen.should == [true]
   end
 end

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

@@ -45,30 +45,15 @@ __END__
 describe "brute/middleware/010_max_iterations" do
   require "brute/messages"
 
-  it "can be added to a stack" do
-    called = false
-    inner = ->(env) { called = true }
-    mw = Brute::Middleware::MaxIterations.new(inner)
-    mw.call({ current_iteration: 1, messages: Brute.log })
-    called.should.be.true
-  end
+  it "lets the turn run under the max, then blocks the stack and injects a notice" do
+    ran = []
+    env = { messages: Brute.log.tap { |l| l.user("hi") }, current_iteration: 1 }
 
-  it "prevents execution after given max" do
-    called = false
-    inner = ->(env) { called = true }
-    mw = Brute::Middleware::MaxIterations.new(inner, max_iterations: 0)
-    env = { current_iteration: 1, messages: Brute.log }
-    mw.call(env)
-    called.should.be.false
-  end
+    Brute::Middleware::MaxIterations.new(->(e) { ran << e[:current_iteration] }).call(env)
+    ran.should == [1]
 
-  it "injects a user message when max is hit" do
-    inner = ->(env) { }
-    mw = Brute::Middleware::MaxIterations.new(inner, max_iterations: 0)
-    session = Brute.log
-    session.user("hi")
-    env = { current_iteration: 1, messages: session }
-    mw.call(env)
+    Brute::Middleware::MaxIterations.new(->(e) { ran << e[:current_iteration] }, max_iterations: 0).call(env)
+    ran.should == [1]
     env[:messages].last.role.should == :user
     env[:messages].last.content.should =~ /Maximum iterations reached/
   end

data/lib/brute/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Brute
-  VERSION = "4.2.0"
+  VERSION = "4.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.3.1
 platform: ruby
 authors:
 - Brute Contributors
@@ -197,14 +197,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 description: Production-grade coding agent with tool execution, middleware pipeline,
   context compaction, session persistence, and multi-provider LLM support.
 executables: []