brute 6.1.1 → 6.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a29376e6820e2ef4e6233073f2012ff95541027b64307956e141af222ece973e
-  data.tar.gz: 94c6351c5526249d3a62d200050180d4880f92bfbe259f3c97fabe5e5663160a
+  metadata.gz: 6ecf8ae2bc514e6cb9cb6cefb1a06476ab68d13b459446ed0c398effcf334a86
+  data.tar.gz: 612dde127eee6f42a4aeb8f6c1fae039d74aaad8c9ed8481de22c0ec6b6cc2ce
 SHA512:
-  metadata.gz: a156cb8659d03cf076b359a2e14e7d462d456433aa5b3a169ec1fcef97b775132ede29b7b838246a2237f32cc5c7e927df513391df61c8e726d14f4101195a5c
-  data.tar.gz: '008a7f1f998bd58467fa13769318d32d27e1d6e92808619dd3a7baed8c3444b263e935a3a435a87405849bab3a7c2ae691a7f0866475b544e6210a61b4215a19'
+  metadata.gz: fe3ee53f5b02b310397b959f307b5ddf8639ab4cedb6d747264a1b49756e65ef93bee312a609898fe03f896a27775b5adabbb30f9e278c71df9ec68a80547e81
+  data.tar.gz: d0cba57fc257001c634474596f82b1b55517ba9f9410106b34a142df1ab8ee6db29d580016dee6db354e181741dcbad0b6be507e048dc6240193ff1cdbedba4f

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/messages.rb

@@ -92,34 +92,12 @@ module Brute
     # What the model thought, for anyone reading rather than replaying.
     def text = blocks.filter_map(&:text).join("\n")
 
-    # Whether these blocks may be sent back to this provider as they are. A
-    # signature the provider did not issue is worse than no signature: it is
-    # a rejected request.
-    def signed_by?(format) = !format.nil? && blocks.any? && issued_by?(format) && blocks.all?(&:signed?)
-
     # Whether this is the sequence the model emitted rather than one built
     # around a plaintext string. Only the former may be replayed: a provider
     # checks what comes back against what it produced, and prose lifted out of
     # a `reasoning` field was never a sequence at all.
     def detailed? = blocks.any? { |block| block.signed? || block.format || block.id }
 
-    # Whether every block came from this provider. The sequence goes back
-    # whole or not at all, so one foreign block disqualifies all of them.
-    #
-    # A block that names no provider is nobody's to vouch for: unsigned there
-    # is nothing to vouch for and it passes, but signed it is a signature that
-    # cannot be attributed, and offering one the provider did not issue is a
-    # rejected request rather than an unverified one.
-    def issued_by?(format)
-      blocks.all? do |block|
-        if block.format.nil?
-          !block.signed?
-        else
-          format.nil? || block.format == format
-        end
-      end
-    end
-
     def to_h(...) = { blocks: blocks.map(&:to_h) }
   end
 
@@ -256,31 +234,6 @@ describe "brute/messages" do
     Brute::Message.new(**m.to_h).should == m
   end
 
-  it "will not vouch for a sequence in which any block is unsigned" do
-    # A provider that verifies signatures rejects a thinking block without
-    # one, so one signed block among several does not make the sequence
-    # sendable: every block has to carry its own signature, or none goes.
-    mixed = Brute::Reasoning.build(blocks: [
-      { type: :text, text: "step one", signature: "sig-1", format: "anthropic-claude-v1" },
-      { type: :text, text: "step two",                     format: "anthropic-claude-v1" },
-    ])
-
-    mixed.signed_by?("anthropic-claude-v1").should.be.false
-  end
-
-  it "will not vouch for a signature that names no provider" do
-    # A block with a signature and no format cannot be attributed, and a
-    # signature the provider did not issue is a rejected request rather than
-    # an unverified one. Unsigned and unstamped is nobody's claim to make, so
-    # it passes.
-    unattributed = Brute::Reasoning.build(text: "thought", signature: "sig-1")
-
-    unattributed.issued_by?("anthropic-claude-v1").should.be.false
-    unattributed.signed_by?("anthropic-claude-v1").should.be.false
-
-    Brute::Reasoning.build(text: "just prose").issued_by?("anthropic-claude-v1").should.be.true
-  end
-
   it "knows a sequence the model produced from one built around a string" do
     # Only what the model actually emitted may be sent back as a sequence, so
     # reasoning coerced from plaintext is not one to be replayed.

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.1"
+  VERSION = "6.1.3"
 end

metadata

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