brute 6.1.2 → 6.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e08acbbd71a23c8da28df07f18d191b8df282b81e43faa49934d123274258090
-  data.tar.gz: 418f3ced0cba3f915859741f43f6e64150651c3f00f05ec05825db38376e9033
+  metadata.gz: f639a3b9b3ec1317f80ee945eb7d610af350d4c862206745aefad42a70afbb4d
+  data.tar.gz: 994bf0aaf3104bfad636338639db4c175de7bbcd468a9abd8f90114c4a8e233e
 SHA512:
-  metadata.gz: 117fccb5ea1751db05c53ff3a4d1ceee66de13b4c3384877ed198cd1c384eaad0eb1344280a04486c013fdb0f956a2aab1038e1c7f156bda144de88e52fd200f
-  data.tar.gz: 9a9deb24a12e26280dd77402489140907ff8760a8232616b8288c1586e345c844c090858435d3662a3258089734fb2a16c1fedca75a271abb4aa9b01ca93c60a
+  metadata.gz: 29b29a00aad896433765e8bbff99ec42422af1c133b4b73231837f85ed7d0ffd4ea2101859fc37ca81c16678860f9a6de72d437d674faf3b9e12d3734f6c36e7
+  data.tar.gz: b43248273fc878a7c553e968b010552a7a670933b694a5a952bb3ecb5c197e08595e5134262475ee296c41b538e601347d34bfc7694cb6880b766e78d8231ea8

data/lib/brute/completion/open_router.rb

@@ -47,8 +47,10 @@ module Brute
           env.emit(LLM_START_EVENT)
 
           messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages], model: options(env).model)
+          raw = nil
 
           ::OpenRouter::Client.new(**@config).then do |client|
+            client.on(:on_error) { |error| raw = error }
             response = nil
             env.emit(LLM_DURATION_EVENT) { response = client.complete(messages, options(env)) }
 
@@ -76,13 +78,13 @@ module Brute
         # 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)
+          env.emit(LLM_FAILURE_EVENT, raw || 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)
-            env.emit(OPEN_ROUTER_SERVER_ERROR_EVENT, error)
+            env.emit(OPEN_ROUTER_SERVER_ERROR_EVENT, raw || error)
 
           else
             env.emit(STANDARD_ERROR_EVENT, error)
@@ -147,6 +149,7 @@ describe "brute/completion/open_router" do
   # Run one turn against a stubbed OpenRouter::Client and hand back the env.
   with_fake_client = lambda do |completion, response|
     fake_client = Object.new
+    fake_client.define_singleton_method(:on) { |_event, &_block| self }
     fake_client.define_singleton_method(:complete) { |_messages, _options| response }
     original = OpenRouter::Client.method(:new)
     OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
@@ -180,6 +183,7 @@ describe "brute/completion/open_router" do
   it "advertises env[:tools] to the provider, and lets a tools: option win" do
     captured = []
     fake_client = Object.new
+    fake_client.define_singleton_method(:on) { |_event, &_block| self }
     fake_client.define_singleton_method(:complete) { |_messages, options| captured << options; FakeUsageResponse.new(nil) }
     original = OpenRouter::Client.method(:new)
     OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
@@ -226,6 +230,7 @@ describe "brute/completion/open_router" do
   it "takes the model from env[:model], and lets a model: option win" do
     captured = []
     fake_client = Object.new
+    fake_client.define_singleton_method(:on) { |_event, &_block| self }
     fake_client.define_singleton_method(:complete) { |_messages, options| captured << options; FakeUsageResponse.new(nil) }
     original = OpenRouter::Client.method(:new)
     OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
@@ -260,6 +265,7 @@ describe "brute/completion/open_router" do
 
     boom = RuntimeError.new("no route to host")
     fake_client = Object.new
+    fake_client.define_singleton_method(:on) { |_event, &_block| self }
     fake_client.define_singleton_method(:complete) { |_messages, _options| raise boom }
     original = OpenRouter::Client.method(:new)
     OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }

data/lib/brute/message_transport/open_router.rb

@@ -13,7 +13,6 @@ module Brute
     #
     #   require "open_router"
     class OpenRouter < MessageTransport
-      EmptyCompletion = Class.new(StandardError)
 
       # What the provider reported about this call — the transport knows its
       # own library's shape, so it knows which detector to ask.
@@ -94,15 +93,6 @@ module Brute
 
           case hash
           in { role: (:system | :user | :assistant | :tool) }
-            # A completion that answered with nothing is not an answer. The
-            # provider was paid for it and something came back -- reasoning,
-            # a refusal, a field this does not know -- and appending it as an
-            # empty assistant message loses the turn quietly: the loop stops
-            # because it is not a tool result, and there is no reply in it.
-            if hash[:role] == :assistant && hash[:content].to_s.strip.empty? && Array(hash[:tool_calls]).empty? && reasoning(hash).nil?
-              raise EmptyCompletion, "the provider answered with no content and no tool calls: #{message.inspect}"
-            end
-
             # Slice away provider extras (refusal, model, ...) that
             # Brute::Message doesn't know. Reasoning is not one of them: it is
             # the model's own thinking and it goes back up with the message.
@@ -193,7 +183,7 @@ describe "brute/message_transport/open_router" do
     out.first.content.should == "hi there"
   end
 
-  it "keeps the model's reasoning, and refuses a completion that answered with nothing at all" do
+  it "keeps the model's reasoning" do
     # Reasoning is the model's own thinking, and it goes back up with the
     # message: a reasoning model that called a tool has to see it on the next
     # pass. Dropping it left an empty assistant message and a lost turn.
@@ -218,22 +208,6 @@ describe "brute/message_transport/open_router" do
       { type: "reasoning.text", text: "step by step", signature: "sig-1" },
     ]
 
-    # A tool call is an answer, even with nothing said alongside it.
-    calling = Struct.new(:choices).new([
-      { "message" => {
-        "role" => "assistant", "content" => nil,
-        "tool_calls" => [{ "id" => "tc1", "type" => "function", "function" => { "name" => "shell", "arguments" => "{}" } }],
-      } },
-    ])
-
-    Brute::MessageTransport::OpenRouter.new(calling).wrap_each.to_a.first.tool_call?.should.be.true
-
-    # Nothing said, nothing thought, nothing called: the provider was paid for
-    # an answer and there is none, which is an error rather than a message.
-    empty = Struct.new(:choices).new([{ "message" => { "role" => "assistant", "content" => "", "refusal" => nil } }])
-
-    lambda { Brute::MessageTransport::OpenRouter.new(empty).wrap_each.to_a }
-      .should.raise(Brute::MessageTransport::OpenRouter::EmptyCompletion)
   end
 
   it "round-trips every detail type under its own payload key" do

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

@@ -50,6 +50,13 @@ module Brute
       # stops when the LLM answers with text only or env[:should_exit] is set
       # (e.g. by MaxIterations).
       #
+      # It also loops on a completion that only thought: a reasoning model
+      # sometimes returns its thinking and stops — no text, no tool call —
+      # having decided what to do without doing it. That is not an answer, and
+      # the turn is not over; the thinking goes back with the conversation,
+      # which is what the provider asks for anyway, and the model does what it
+      # had already worked out.
+      #
       #   use Brute::Middleware::Loop::ToolResult
       #
       class ToolResult < Loop
@@ -58,7 +65,7 @@ module Brute
             next false
           end
 
-          unless env[:messages].last&.role == :tool
+          unless env[:messages].last&.role == :tool || ToolResult.thought_only?(env[:messages].last)
             next false
           end
 
@@ -67,6 +74,14 @@ module Brute
           true
         end
 
+        # Thinking, and nothing done with it.
+        def self.thought_only?(message)
+          message&.role == :assistant &&
+            message.reasoning &&
+            message.content.to_s.strip.empty? &&
+            !message.tool_call?
+        end
+
         def initialize(app)
           super(app, CONDITION)
         end
@@ -136,6 +151,26 @@ describe "brute/middleware/006_loop" do
 
   # --- Loop::BackgroundJobs ---
 
+  it "ToolResult reruns on a completion that only thought, so the turn is not lost" do
+    # A reasoning model sometimes returns the thinking and stops, having
+    # decided what to do without doing it. The turn is not over: the thinking
+    # goes back and the model does what it had worked out.
+    thought = Brute::Message.new(role: :assistant, reasoning: "I should list the events")
+
+    env = { messages: Brute.log.tap { |log| log << thought }, current_iteration: 1 }
+    Brute::Middleware::Loop::ToolResult::CONDITION.call(env).should.be.true
+    env[:current_iteration].should == 2
+
+    # An answer, or a tool call it did make, ends the turn as before.
+    answered = { messages: Brute.log.tap { |log| log.assistant("here they are") }, current_iteration: 1 }
+    Brute::Middleware::Loop::ToolResult::CONDITION.call(answered).should.be.false
+
+    calling = Brute::Message.new(role: :assistant, reasoning: "I should list them",
+      tool_calls: [{ id: "tc1", name: "list_events", arguments: {} }])
+    called = { messages: Brute.log.tap { |log| log << calling }, current_iteration: 1 }
+    Brute::Middleware::Loop::ToolResult::CONDITION.call(called).should.be.false
+  end
+
   it "BackgroundJobs reruns while jobs are running" do
     seen = []
     inner = ->(env) { seen << env[:background_jobs]; env[:background_jobs] = seen.size < 3 }

data/lib/brute/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 6.1.2
+  version: 6.1.4
 platform: ruby
 authors:
 - Brute Contributors