brute 6.1.0 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a640b2c8ee7c0ca3d79e5618b3026494e48115c4bc38799e2d1ba1ca1acc968f
-  data.tar.gz: 66fed78b88d735cc528669e08dca7edbebfd1e6ba712f079fde45d268c9a5ec2
+  metadata.gz: a29376e6820e2ef4e6233073f2012ff95541027b64307956e141af222ece973e
+  data.tar.gz: 94c6351c5526249d3a62d200050180d4880f92bfbe259f3c97fabe5e5663160a
 SHA512:
-  metadata.gz: a5374a6f3194a224069e812c3d49ef0748ca1e6b03d13ea0ef5e645103e6d67ec08f92f4702a86bce78733844c59472a571b9012268759e1a92693ce61b12b83
-  data.tar.gz: aab38ce15e5fec92937cdef94a9350e880cf0ab52bce6e1706ed586fc720c204b94a8ca98e4021dce069a0ae058447194e615d6c8c29990debcd30f88a0a6907
+  metadata.gz: a156cb8659d03cf076b359a2e14e7d462d456433aa5b3a169ec1fcef97b775132ede29b7b838246a2237f32cc5c7e927df513391df61c8e726d14f4101195a5c
+  data.tar.gz: '008a7f1f998bd58467fa13769318d32d27e1d6e92808619dd3a7baed8c3444b263e935a3a435a87405849bab3a7c2ae691a7f0866475b544e6210a61b4215a19'

data/lib/brute/message_transport/anthropic.rb

@@ -28,6 +28,10 @@ module Brute
     # a user message — consecutive tool results are folded into one user
     # turn so roles keep alternating.
     class Anthropic < MessageTransport
+      # An assistant message this cannot put on the wire, because Anthropic
+      # takes no empty content and there is nothing in it to send.
+      EmptyMessage = Class.new(StandardError)
+
       # Whose signatures these are. OpenRouter names the same format when it
       # proxies Claude, so thinking that came back through it goes home.
       FORMAT = "anthropic-claude-v1"
@@ -54,69 +58,86 @@ module Brute
       def self.dump(message, model: nil)
         case message.role
         when :tool
-          { role: "user", content: [tool_result_block(message)] }
+          { role: "user", content: [ tool_result_block(message) ] }
         when :assistant
-          if message.tool_call?
-            blocks = thinking_blocks(message)
-            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
-            blocks = thinking_blocks(message)
-            unless message.content.to_s.empty?
-              blocks << { type: "text", text: message.content }
-            end
-
-            # Anthropic rejects an empty text block, so a message with nothing
-            # left to send goes as plain content rather than an empty one.
-            if blocks.empty?
-              { role: "assistant", content: message.content }
-            else
-              { role: "assistant", content: blocks }
-            end
-          end
+          { role: "assistant", content: assistant_content(message) }
         else
           { role: message.role.to_s, content: message.content }
         end
       end
 
-      # Thinking goes back first and unmodified. A signature Anthropic did
-      # not issue cannot be verified -- a conversation replayed from another
-      # provider carries thinking that is not Anthropic's -- and an
-      # unverifiable block is a 400, so it sends none rather than a bad one.
-      # Anthropic has two kinds of thinking block and no third: a summary is
-      # a precis of thinking the provider would not show, and the signature
-      # was issued over the thinking rather than the precis. Sent as a
-      # thinking block it is a block that does not verify, so a sequence
-      # carrying one is refused whole -- the same as a foreign format.
+      # The assistant turn's content blocks, in the order the wire wants
+      # them: thinking first, because the sequence is part of what Anthropic
+      # verifies, then what was said, then what was called.
+      #
+      # Anthropic takes no empty content -- not an empty string, not an empty
+      # block, not an empty array -- so a message with nothing in it is not
+      # one this can express. It says so rather than sending a request that
+      # is already a 400.
+      def self.assistant_content(message)
+        blocks = thinking_blocks(message)
+
+        unless message.content.to_s.empty?
+          blocks << { type: "text", text: message.content }
+        end
+
+        if message.tool_call?
+          blocks += message.tool_calls.map do |tc|
+            { type: "tool_use", id: tc.id, name: tc.name, input: tc.arguments }
+          end
+        end
+
+        if blocks.empty?
+          raise EmptyMessage, "an assistant message with no content, no tool calls and no thinking Anthropic can take: #{message.inspect}"
+        end
+
+        blocks
+      end
+
+      # Whether every stored block has an Anthropic form. There are two of
+      # them and no third -- `thinking` and `redacted_thinking` -- and both
+      # carry a payload Anthropic issued and checks on the way back. So a
+      # block another provider signed, one carrying no signature at all, and
+      # a summary (which is a precis, and has no block of its own here) each
+      # have no form to take. The sequence goes whole or not at all, because
+      # what Anthropic verifies is the sequence, so one such block answers
+      # for the rest.
       def self.expressible?(reasoning)
-        reasoning.blocks.all? { |block| block.type == :text || block.opaque? }
+        reasoning.blocks.any? && reasoning.blocks.all? do |block|
+          block.format == FORMAT && block.signed? && (block.type == :text || block.opaque?)
+        end
       end
 
+      # The stored blocks as Anthropic content blocks, in order. Where the
+      # sequence has no Anthropic form there is nothing to send -- an
+      # unverifiable block is a 400, and no thinking beats a failed request.
       def self.thinking_blocks(message)
-        if message.reasoning&.signed_by?(FORMAT) && expressible?(message.reasoning)
-          message.reasoning.blocks.map do |block|
-            if block.opaque?
-              { type: "redacted_thinking", data: block.signature }
-            else
-              { type: "thinking", thinking: block.text.to_s, signature: block.signature }
-            end
-          end
+        if message.reasoning && expressible?(message.reasoning)
+          message.reasoning.blocks.map { |block| thinking_param(block) }
         else
           []
         end
       end
 
+      # One stored block as the content block Anthropic named it. The
+      # opaque payload rides under `data`, the readable one under `thinking`
+      # with the signature that verifies it.
+      def self.thinking_param(block)
+        if block.opaque?
+          { type: "redacted_thinking", data: block.signature }
+        else
+          { type: "thinking", thinking: block.text.to_s, signature: block.signature }
+        end
+      end
+
       # A thinking block, or the redacted one that stands in for it when the
       # provider will not show its working. Both go back whole.
       def self.thinking_block(block)
         case block.type
         when :thinking
-          Brute::Reasoning::Block.new(type: :text, text: block.thinking, signature: block.signature, format: FORMAT)
+          Brute::ReasoningBlock.new(type: :text, text: block.thinking, signature: block.signature, format: FORMAT)
         when :redacted_thinking
-          Brute::Reasoning::Block.new(type: :encrypted, signature: block.data, format: FORMAT)
+          Brute::ReasoningBlock.new(type: :encrypted, signature: block.data, format: FORMAT)
         end
       end
 
@@ -245,6 +266,27 @@ describe "brute/message_transport/anthropic" do
     end
   end
 
+  it "says so rather than sending content Anthropic will not take" do
+    # Anthropic takes no empty content -- not an empty string, not an empty
+    # block, not an empty array. An assistant message with nothing said,
+    # nothing called and no thinking it can express has no form here, and
+    # went out as `content: ""`: a 400, and one that poisons every later
+    # request in the same conversation.
+    nothing = Brute::Message.new(role: :assistant, content: "")
+
+    lambda { Brute::MessageTransport::Anthropic.dump(nothing) }
+      .should.raise(Brute::MessageTransport::Anthropic::EmptyMessage)
+
+    # Thinking alone is something said, so it goes as itself.
+    thought = Brute::Message.new(role: :assistant, content: "", reasoning: {
+      blocks: [{ type: :text, text: "let me think", signature: "sig-1", format: "anthropic-claude-v1" }],
+    })
+
+    Brute::MessageTransport::Anthropic.dump(thought)[:content].should == [
+      { type: "thinking", thinking: "let me think", signature: "sig-1" },
+    ]
+  end
+
   it "wraps text and tool_use blocks into one assistant message" do
     response = fake_response.new(content: [
       fake_text_block.new(type: :text, text: "running ls"),

data/lib/brute/message_transport/open_router.rb

@@ -20,63 +20,34 @@ module Brute
       def self.usage_metrics(response)
         Brute::UsageDetection::OpenRouter.detect(response)
       end
-      # Reasoning goes back up with the message it belongs to: a reasoning
-      # model that called a tool has to see its own thinking on the next pass,
-      # or it answers the tool call without the thinking that asked for it.
+      # OpenRouter takes reasoning back either way: `reasoning_details` is
+      # the sequence the model produced, each entry carrying its own type,
+      # payload and signature, and `reasoning` is the same thinking as plain
+      # prose. The details are the complete form, so they are what goes when
+      # there are details to send; prose that was only ever prose -- read off
+      # a `reasoning` field, or off a library that reports nothing else --
+      # goes as prose, because a details array built around it would be a
+      # sequence the model never produced.
       #
-      # OpenRouter takes it either as the plain `reasoning` string or as the
-      # whole `reasoning_details` array, which is what carries the signature.
-      # The sequence has to match what the model produced -- it may not be
-      # rearranged or modified -- so what came back is what goes out.
+      # Which of the two is a property of what was stored, not a judgement
+      # about where the turn is headed. Where it is headed is the caller's to
+      # decide; this only turns one shape into the other.
       def self.dump(message, model: nil)
         message.to_h.tap do |hash|
           # What Message#to_h holds is brute's own shape, which is not the
           # wire's: whatever goes out under these keys is put there here.
           hash.delete(:reasoning)
 
-          if message.reasoning
-            # An encrypted payload has no prose in it, and an empty string is
-            # not reasoning: the details carry it, or nothing does.
-            unless message.reasoning.text.empty?
-              hash[:reasoning] = message.reasoning.text
-            end
+          reasoning = message.reasoning
 
-            # The details go back whole, in order, or not at all -- the
-            # sequence has to match what the model produced. OpenRouter routes
-            # to many providers, so "signed" is not enough: a Claude signature
-            # is only good while the turn is still going to Claude. Switch
-            # model mid-conversation and the plaintext survives while the
-            # signatures, which the new provider cannot verify, do not.
-            # Whole or not at all: dropping an entry out of the middle is
-            # modifying the sequence, which is what the provider forbids. A
-            # plaintext-only reasoning has nothing signed in it, so no array
-            # is invented around it.
-            if message.reasoning.detailed? && message.reasoning.blocks.all? { |block| issued_by?(block, model) }
-              hash[:reasoning_details] = message.reasoning.blocks.map { |block| detail(block) }
-            end
+          if reasoning&.detailed?
+            hash[:reasoning_details] = reasoning.blocks.map { |block| detail(block) }
+          elsif reasoning && !reasoning.text.empty?
+            hash[:reasoning] = reasoning.text
           end
         end
       end
 
-      # OpenRouter names both sides after the provider: a model id reads
-      # "anthropic/claude-sonnet-4", a format "anthropic-claude-v1". Asked
-      # about no model in particular, the format is taken at its word.
-      def self.issued_by?(block, model)
-        vendor = model.to_s.split("/").first
-
-        if block.format.nil?
-          # A signature that names no provider cannot be attributed to this
-          # one; unsigned there is nothing to attribute and it passes.
-          !block.signed?
-        elsif vendor.nil? || vendor == model.to_s
-          # No model, or an id that names no vendor: nothing to contradict the
-          # format, so it is taken at its word rather than dropped silently.
-          true
-        else
-          block.format.split("-").first == vendor
-        end
-      end
-
       # Each type names its own payload: reasoning text carries `text` and the
       # `signature` that verifies it, a summary carries `summary`, and an
       # encrypted item carries `data`. Written under the wrong key the payload
@@ -161,24 +132,19 @@ module Brute
           end
         end
 
-        def answering_model
-          if @result.respond_to?(:model)
-            @result.model
-          end
-        end
-
         # The type names the payload's key, so it says which one to read.
         def block(detail)
           type = detail[:type].to_s.split(".").last.to_s
 
-          Brute::Reasoning::Block.new(
+          Brute::ReasoningBlock.new(
             type:      type.empty? ? :text : type.to_sym,
             text:      detail[:text] || detail[:summary],
             signature: detail[:signature] || detail[:data],
-            # A provider that names no format still answered as some model,
-            # and an unattributed signature is one nobody may replay -- so the
-            # model that produced it stands in for the format it did not send.
-            format:    detail[:format] || answering_model,
+            # Straight off the wire. `format` names a structure OpenRouter
+            # documents a closed set of ("anthropic-claude-v1",
+            # "openai-responses-v1", ... "unknown"); a model id is not one of
+            # them, so where the wire named none, none is stored.
+            format:    detail[:format],
             id:        detail[:id],
             index:     detail[:index],
           )
@@ -237,19 +203,19 @@ describe "brute/message_transport/open_router" do
     reasoned.reasoning.text.should == "thought about it"
     Brute::MessageTransport::OpenRouter.dump(reasoned)[:reasoning].should == "thought about it"
 
-    # Signed thinking goes back as the details array, unmodified, which is
-    # what carries the signature the provider checks.
-    # A detail that names no format is stamped with the model that answered,
-    # because a signature nobody claims is one nobody may replay.
+    # Signed thinking goes back as the details array, entry for entry. The
+    # details are the complete form, so they carry the turn on their own --
+    # `reasoning` is the same thinking as prose, and sending both says it
+    # twice.
     signed = Struct.new(:choices, :model).new([{ "message" => {
       "role" => "assistant", "content" => "",
       "reasoning_details" => [{ "type" => "reasoning.text", "text" => "step by step", "signature" => "sig-1" }],
     } }], "anthropic/claude-sonnet-4")
 
     back = Brute::MessageTransport::OpenRouter.dump(Brute::MessageTransport::OpenRouter.new(signed).wrap_each.to_a.first)
-    back[:reasoning].should == "step by step"
+    back.key?(:reasoning).should.be.false
     back[:reasoning_details].should == [
-      { type: "reasoning.text", format: "anthropic/claude-sonnet-4", text: "step by step", signature: "sig-1" },
+      { type: "reasoning.text", text: "step by step", signature: "sig-1" },
     ]
 
     # A tool call is an answer, even with nothing said alongside it.
@@ -310,23 +276,54 @@ describe "brute/message_transport/open_router" do
     end
   end
 
-  it "sends the details sequence whole, or not at all" do
+  it "stores the format the wire named, and no other" do
+    # `format` names one of a closed set of structures OpenRouter documents
+    # -- "anthropic-claude-v1", "openai-responses-v1", ... "unknown". A model
+    # id is not one of them, so where the wire named no format, none is
+    # stored and none is sent: an invented one is a value the API does not
+    # take, and a value nothing else in here can read back.
+    named = Struct.new(:choices, :model).new([
+      { "message" => { "role" => "assistant", "content" => "done", "reasoning_details" => [
+        { "type" => "reasoning.text", "text" => "step by step", "signature" => "sig-1",
+          "format" => "anthropic-claude-v1" },
+      ] } },
+    ], "anthropic/claude-sonnet-4")
+
+    unnamed = Struct.new(:choices, :model).new([
+      { "message" => { "role" => "assistant", "content" => "done", "reasoning_details" => [
+        { "type" => "reasoning.text", "text" => "step by step", "signature" => "sig-1" },
+      ] } },
+    ], "anthropic/claude-sonnet-4")
+
+    Brute::MessageTransport::OpenRouter.new(named).wrap_each.to_a.first
+      .reasoning.blocks.first.format.should == "anthropic-claude-v1"
+
+    Brute::MessageTransport::OpenRouter.new(unnamed).wrap_each.to_a.first
+      .reasoning.blocks.first.format.should.be.nil
+  end
+
+  it "sends the details sequence whole, entry for entry" do
     # "The entire sequence of consecutive reasoning blocks must match the
     # outputs generated by the model; you cannot rearrange or modify the
-    # sequence." A subset of it is a modified sequence, so a turn going to
-    # another provider keeps the plaintext and drops the array entire.
+    # sequence." So every entry goes, in order, as it was stored -- what the
+    # turn is then sent to is the caller's to decide, not this.
     response = Struct.new(:choices).new([
       { "message" => { "role" => "assistant", "content" => "done", "reasoning_details" => [
         { "type" => "reasoning.text", "text" => "step by step", "signature" => "sig-1",
-          "format" => "anthropic-claude-v1" },
+          "format" => "anthropic-claude-v1", "index" => 0 },
+        { "type" => "reasoning.encrypted", "data" => "b64blob",
+          "format" => "anthropic-claude-v1", "index" => 1 },
       ] } },
     ])
 
     wrapped = Brute::MessageTransport::OpenRouter.new(response).wrap_each.to_a.first
 
-    elsewhere = Brute::MessageTransport::OpenRouter.dump(wrapped, model: "openai/gpt-5")
-    elsewhere[:reasoning].should == "step by step"
-    elsewhere.key?(:reasoning_details).should.be.false
+    Brute::MessageTransport::OpenRouter.dump(wrapped)[:reasoning_details].should == [
+      { type: "reasoning.text", format: "anthropic-claude-v1", index: 0,
+        text: "step by step", signature: "sig-1" },
+      { type: "reasoning.encrypted", format: "anthropic-claude-v1", index: 1,
+        data: "b64blob" },
+    ]
   end
 
   it "does not invent a details sequence around plaintext reasoning" do

data/lib/brute/message_transport/ruby_llm.rb

@@ -6,7 +6,50 @@ require "brute/message_transport"
 
 module Brute
   class MessageTransport
+    # MessageTransport for the ruby_llm gem (https://github.com/crmne/ruby_llm).
+    # Brute does not require it — you do:
+    #
+    #   require "ruby_llm"
+    #
+    # The gem changed shape at 2.0, and it changed in exactly the place that
+    # decides what this transport can promise. Through 1.x a message models
+    # its reasoning as a RubyLLM::Thinking: one text, one signature, and
+    # nowhere to put a sequence -- so a sequence cannot come back out of it
+    # the way it went in. 2.0 adds #raw_reasoning, which holds the whole
+    # reasoning_details sequence and which the provider adapters send on, so
+    # every entry goes back with the type, payload and signature it had. The
+    # model id moved too: #model_id in 1.x, #model in 2.0.
+    #
+    # Two shapes, so two subclasses, and .for is the only place that asks
+    # which one is installed. Nothing else branches on a version.
     class RubyLLM < MessageTransport
+      # The release that added somewhere for a whole sequence to live.
+      VERBATIM = Gem::Version.new("2.0")
+
+      # Which subclass the bundled gem calls for. Read lazily: brute does not
+      # require ruby_llm, so ::RubyLLM only exists once the caller has.
+      def self.for(version = ::RubyLLM::VERSION)
+        if Gem::Version.new(version) >= VERBATIM
+          V2
+        else
+          V1
+        end
+      end
+
+      # Brute::MessageTransport::RubyLLM.new(response) answers whichever
+      # subclass fits; asking a subclass for one builds it as usual.
+      def self.new(result)
+        if self == RubyLLM
+          self.for.new(result)
+        else
+          super
+        end
+      end
+
+      # Dispatchers. Both subclasses override these.
+      def self.dump(message, model: nil) = self.for.dump(message, model: model)
+
+      def self.thinking(message) = self.for.thinking(message)
 
       # What the provider reported about this call — the transport knows its
       # own library's shape, so it knows which detector to ask.
@@ -14,80 +57,200 @@ module Brute
         Brute::UsageDetection::RubyLLM.detect(message)
       end
 
-      # Brute::Message -> RubyLLM::Message (tool calls as ruby_llm's id-keyed hash).
-      def self.dump(message, model: nil)
-        tool_calls = message.tool_calls&.to_h do |tc|
-          [tc.id, ::RubyLLM::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments)]
+      # ruby_llm keys tool calls by id; brute keeps a flat list.
+      def self.tool_calls(message)
+        message.tool_calls&.to_h do |tc|
+          [ tc.id, ::RubyLLM::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments) ]
+        end
+      end
+
+      private
+
+        # RubyLLM::Message -> Brute::Message.
+        def wrap(message)
+          raw_calls = message.tool_calls
+          if raw_calls.respond_to?(:values)
+            calls_list = raw_calls.values
+          else
+            calls_list = raw_calls
+          end
+
+          tool_calls = calls_list&.map do |tc|
+            Brute::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments)
+          end
+
+          Brute::Message.new(
+            role:         message.role,
+            content:      message.content&.to_s, # Preserves nil safely
+            tool_calls:   tool_calls,
+            tool_call_id: message.tool_call_id,
+            reasoning:    reasoning(message),
+          )
         end
 
+        # The thinking ruby_llm flattened: one text and one signature, which
+        # is all 1.x ever has, and all 2.0 has when the provider adapter
+        # kept no reasoning_details of its own.
+        def flattened(message)
+          if message.respond_to?(:thinking) && message.thinking
+            Brute::Reasoning.build(
+              text:      message.thinking.text,
+              signature: message.thinking.signature,
+              format:    answering_model(message),
+            )
+          end
+        end
+    end
+
+    # ruby_llm 1.x. A message carries RubyLLM::Thinking and nothing else, so
+    # a sequence of more than one block has nowhere to live: it would go back
+    # as one block holding the joined text and the first signature, which is
+    # a modified sequence and a 400. Nothing goes instead.
+    class RubyLLM::V1 < RubyLLM
+      def self.dump(message, model: nil)
         ::RubyLLM::Message.new(
           role:         message.role,
           content:      message.content,
-          tool_calls:   tool_calls,
+          tool_calls:   tool_calls(message),
           tool_call_id: message.tool_call_id,
           thinking:     thinking(message),
         )
       end
 
-      # RubyLLM::Thinking.build answers nil when there is nothing to say, and
-      # takes the signature back exactly as it came. The signature lives on
-      # the block that was signed, not on the sequence.
+      # One block or none. RubyLLM::Thinking.build answers nil when there is
+      # nothing to say; empty text is passed as nil rather than "" so an
+      # encrypted payload renders as redacted_thinking rather than as a
+      # thinking block with an empty body.
       def self.thinking(message)
-        if message.reasoning
+        reasoning = message.reasoning
+
+        if reasoning&.blocks&.one?
+          block = reasoning.blocks.first
+
           ::RubyLLM::Thinking.build(
-            text:      message.reasoning.text,
-            signature: message.reasoning.blocks.find(&:signed?)&.signature,
+            text:      block.text.to_s.empty? ? nil : block.text,
+            signature: block.signature,
           )
         end
       end
 
       private
 
-      # RubyLLM::Message -> Brute::Message.
-        def wrap(message)
-          raw_calls = message.tool_calls
-          if raw_calls.respond_to?(:values)
-            calls_list = raw_calls.values
+        # 1.x names it #model_id.
+        def answering_model(message)
+          if message.respond_to?(:model_id)
+            message.model_id
+          end
+        end
+
+        def reasoning(message) = flattened(message)
+    end
+
+    # ruby_llm 2.0 and later. #raw_reasoning holds the reasoning_details
+    # sequence and the provider adapters send it on, so a sequence goes home
+    # entry for entry. Where the adapter kept none there is still #thinking,
+    # which carries one text and one signature.
+    class RubyLLM::V2 < RubyLLM
+      def self.dump(message, model: nil)
+        ::RubyLLM::Message.new(
+          role:          message.role,
+          content:       message.content,
+          tool_calls:    tool_calls(message),
+          tool_call_id:  message.tool_call_id,
+          thinking:      thinking(message),
+          raw_reasoning: raw_reasoning(message),
+        )
+      end
+
+      # 2.0 hands #raw_reasoning to the provider as the reasoning_details
+      # array, so the stored sequence goes out in that shape: each block
+      # under the type that names it, and its payload under the key that
+      # type gives it. Prose that was only ever prose has no sequence to
+      # make of itself, and travels on #thinking instead.
+      def self.raw_reasoning(message)
+        reasoning = message.reasoning
+
+        if reasoning&.detailed?
+          reasoning.blocks.map { |block| detail(block) }
+        end
+      end
+
+      # One stored block as a reasoning detail. Reasoning text carries
+      # `text` and the `signature` that verifies it, a summary carries
+      # `summary`, and an encrypted item carries `data` -- written under the
+      # wrong key the payload is simply lost.
+      def self.detail(block)
+        named = {
+          type:   "reasoning.#{block.type}",
+          format: block.format,
+          id:     block.id,
+          index:  block.index,
+        }
+
+        case block.type
+        when :encrypted
+          named.merge(data: block.signature).compact
+        when :summary
+          named.merge(summary: block.text).compact
         else
-          calls_list = raw_calls
+          named.merge(text: block.text, signature: block.signature).compact
         end
+      end
 
-          tool_calls = calls_list&.map do |tc|
-            Brute::ToolCall.new(
-              id:        tc.id,
-              name:      tc.name,
-              arguments: tc.arguments,
-            )
-          end
+      # The readable view. #raw_reasoning is what actually goes back out;
+      # this is what a human sees, and what a provider adapter that kept no
+      # payload falls back on.
+      def self.thinking(message)
+        reasoning = message.reasoning
 
-          Brute::Message.new(
-            role:         message.role,
-            content:      message.content&.to_s, # Preserves nil safely
-            tool_calls:   tool_calls,
-            tool_call_id: message.tool_call_id,
-            reasoning:    reasoning(message),
+        if reasoning
+          ::RubyLLM::Thinking.build(
+            text:      reasoning.text.empty? ? nil : reasoning.text,
+            signature: reasoning.blocks.find(&:signed?)&.signature,
           )
         end
+      end
+
+      private
 
+        # 2.0 names it #model.
         def answering_model(message)
           if message.respond_to?(:model)
             message.model
           end
         end
 
-        # RubyLLM models it as a Thinking, carrying the text and the
-        # provider's signature for it. It speaks to many providers, so the
-        # model that issued the signature is what stamps the block: unstamped,
-        # it would be offered to whichever provider asked next.
+        # The reasoning_details sequence where the adapter kept one, and
+        # ruby_llm's flattened view where it did not.
         def reasoning(message)
-          if message.respond_to?(:thinking) && message.thinking
-            Brute::Reasoning.build(
-              text:      message.thinking.text,
-              signature: message.thinking.signature,
-              format:    answering_model(message),
-            )
+          details = []
+          if message.respond_to?(:raw_reasoning)
+            details = Array(message.raw_reasoning)
+          end
+
+          if details.empty?
+            flattened(message)
+          else
+            Brute::Reasoning.build(blocks: details.map { |detail| block(detail) })
           end
         end
+
+        # One reasoning detail as a stored block. The type names which key
+        # the payload arrived under.
+        def block(detail)
+          hash = detail.to_h.transform_keys(&:to_sym)
+          type = hash[:type].to_s.split(".").last.to_s
+
+          Brute::ReasoningBlock.new(
+            type:      type.empty? ? :text : type.to_sym,
+            text:      hash[:text] || hash[:summary],
+            signature: hash[:signature] || hash[:data],
+            format:    hash[:format],
+            id:        hash[:id],
+            index:     hash[:index],
+
+          )
+        end
     end
   end
 end
@@ -96,52 +259,144 @@ __END__
 
 describe "brute/message_transport/ruby_llm" do
   require "brute/messages"
+  require "ruby_llm"
 
   # Duck-typed stand-ins for RubyLLM::Message / RubyLLM::ToolCall so these
-  # specs don't need the gem loaded.
+  # specs don't need a particular version of the gem loaded. The 2.0 shape is
+  # not installable alongside the 1.x one, so it is stood in for.
   fake_tool_call = Struct.new(:id, :name, :arguments, keyword_init: true)
   fake_message   = Struct.new(:role, :content, :tool_calls, :tool_call_id, keyword_init: true)
+  fake_thinking  = Struct.new(:text, :signature, keyword_init: true)
+
+  it "picks the subclass its bundled gem calls for" do
+    # 1.x models thinking as one text and one signature; 2.0 keeps the
+    # whole reasoning_details sequence. Two shapes, two subclasses.
+    Brute::MessageTransport::RubyLLM.for("1.14.1").should == Brute::MessageTransport::RubyLLM::V1
+    Brute::MessageTransport::RubyLLM.for("1.16.0").should == Brute::MessageTransport::RubyLLM::V1
+    Brute::MessageTransport::RubyLLM.for("2.0.0").should  == Brute::MessageTransport::RubyLLM::V2
+    Brute::MessageTransport::RubyLLM.for("2.4.0").should  == Brute::MessageTransport::RubyLLM::V2
+  end
+
+  it "builds the subclass, not the dispatcher" do
+    m = fake_message.new(role: :assistant, content: "hi")
+    Brute::MessageTransport::RubyLLM.new(m).should.be.kind_of?(Brute::MessageTransport::RubyLLM)
+    Brute::MessageTransport::RubyLLM::V1.new(m).should.be.kind_of?(Brute::MessageTransport::RubyLLM::V1)
+  end
 
   it "wraps a plain assistant message" do
     m = fake_message.new(role: :assistant, content: "hi")
-    out = Brute::MessageTransport::RubyLLM.new(m).wrap_each.to_a
+    out = Brute::MessageTransport::RubyLLM::V1.new(m).wrap_each.to_a
     out.first.should.be.kind_of?(Brute::Message)
     out.first.content.should == "hi"
   end
 
-  it "sends thinking back with the signature its block carried" do
-    # ruby_llm models thinking as one text and one signature, so a sequence of
-    # blocks flattens to its text and the signature of the block carrying one.
-    require "ruby_llm"
+  it "wraps ruby_llm's id-keyed tool_calls hash into a flat list" do
+    tc = fake_tool_call.new(id: "tc1", name: "shell", arguments: { "command" => "ls" })
+    m = fake_message.new(role: :assistant, content: "", tool_calls: { "tc1" => tc })
+
+    out = Brute::MessageTransport::RubyLLM::V1.new(m).wrap_each.to_a.first
+    out.tool_calls.first.should == Brute::ToolCall.new(id: "tc1", name: "shell", arguments: { "command" => "ls" })
+  end
+
+  it "stamps the model that answered, under the name 1.x gives it" do
+    # RubyLLM::Message names it #model_id through 1.x -- there is no #model,
+    # so asking for one stamped nothing and the signature went out
+    # unattributed.
+    m = fake_message.new(role: :assistant, content: "done")
+    m.define_singleton_method(:thinking) { fake_thinking.new(text: "thought", signature: "sig-1") }
+    m.define_singleton_method(:model_id) { "claude-sonnet-4" }
 
+    block = Brute::MessageTransport::RubyLLM::V1.new(m).wrap_each.to_a.first.reasoning.blocks.first
+    block.signature.should == "sig-1"
+    block.format.should == "claude-sonnet-4"
+  end
+
+  it "sends one block back with the signature it carried" do
     m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
       blocks: [{ type: :text, text: "thought it through", signature: "sig-1" }],
     })
 
-    thinking = Brute::MessageTransport::RubyLLM.dump(m).thinking
+    thinking = Brute::MessageTransport::RubyLLM::V1.dump(m).thinking
     thinking.text.should == "thought it through"
     thinking.signature.should == "sig-1"
   end
 
-  it "stamps the model that signed the thinking it wrapped" do
-    # ruby_llm speaks to many providers, so a signature it hands back is only
-    # good against the model that issued it. Unstamped, it would be offered to
-    # whichever provider asked next.
-    thinking = Struct.new(:text, :signature, keyword_init: true)
+  it "sends nothing rather than a sequence 1.x cannot hold" do
+    # RubyLLM::Thinking has room for one text and one signature. A sequence
+    # put through it comes out as the joined text under the first block's
+    # signature, which is a modified sequence -- a 400, not a near miss. So
+    # it does not go.
+    m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+      blocks: [
+        { type: :text, text: "step one", signature: "sig-1", format: "anthropic-claude-v1" },
+        { type: :text, text: "step two", signature: "sig-2", format: "anthropic-claude-v1" },
+      ],
+    })
+
+    Brute::MessageTransport::RubyLLM::V1.dump(m).thinking.should.be.nil
+  end
+
+  it "hands an encrypted payload over as a payload, not as empty thinking" do
+    # An encrypted block has no prose. Passed as "" rather than nil it renders
+    # as a thinking block with an empty body; passed as nil ruby_llm renders
+    # the redacted_thinking block the payload actually belongs in.
+    m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+      blocks: [{ type: :encrypted, signature: "b64blob", format: "anthropic-claude-v1" }],
+    })
+
+    thinking = Brute::MessageTransport::RubyLLM::V1.dump(m).thinking
+    thinking.text.should.be.nil
+    thinking.signature.should == "b64blob"
+  end
+
+  it "round-trips a reasoning_details sequence, entry for entry" do
+    # 2.0 hands #raw_reasoning on to the provider, so each entry goes back
+    # under the type that named it with the payload that type gives it.
+    details = [
+      { "type" => "reasoning.text", "text" => "step one", "signature" => "sig-1",
+        "format" => "anthropic-claude-v1", "index" => 0 },
+      { "type" => "reasoning.encrypted", "data" => "b64blob",
+        "format" => "anthropic-claude-v1", "index" => 1 },
+    ]
+
     m = fake_message.new(role: :assistant, content: "done")
-    m.define_singleton_method(:thinking) { thinking.new(text: "thought", signature: "sig-1") }
-    m.define_singleton_method(:model) { "claude-sonnet-4" }
+    m.define_singleton_method(:raw_reasoning) { details }
 
-    block = Brute::MessageTransport::RubyLLM.new(m).wrap_each.to_a.first.reasoning.blocks.first
-    block.signature.should == "sig-1"
-    block.format.should == "claude-sonnet-4"
+    wrapped = Brute::MessageTransport::RubyLLM::V2.new(m).wrap_each.to_a.first
+
+    wrapped.reasoning.text.should == "step one"
+    wrapped.reasoning.blocks.map(&:type).should == [:text, :encrypted]
+
+    # ...and back out in the shape it came in, entry for entry.
+    Brute::MessageTransport::RubyLLM::V2.raw_reasoning(wrapped).should == [
+      { type: "reasoning.text", format: "anthropic-claude-v1", index: 0,
+        text: "step one", signature: "sig-1" },
+      { type: "reasoning.encrypted", format: "anthropic-claude-v1", index: 1,
+        data: "b64blob" },
+    ]
   end
 
-  it "wraps ruby_llm's id-keyed tool_calls hash into a flat list" do
-    tc = fake_tool_call.new(id: "tc1", name: "shell", arguments: { "command" => "ls" })
-    m = fake_message.new(role: :assistant, content: "", tool_calls: { "tc1" => tc })
+  it "makes no details sequence out of prose that was only ever prose" do
+    # A sequence brute invented is not one the model produced, so plaintext
+    # travels as plaintext -- on #thinking, where a reader finds it -- and no
+    # reasoning_details array is built around it.
+    plain = Brute::Message.new(role: :assistant, content: "done", reasoning: "just thinking")
 
-    out = Brute::MessageTransport::RubyLLM.new(m).wrap_each.to_a.first
-    out.tool_calls.first.should == Brute::ToolCall.new(id: "tc1", name: "shell", arguments: { "command" => "ls" })
+    Brute::MessageTransport::RubyLLM::V2.raw_reasoning(plain).should.be.nil
+    Brute::MessageTransport::RubyLLM::V2.dump(plain).thinking.text.should == "just thinking"
+  end
+
+  it "falls back to the flattened view when the adapter kept no details" do
+    # Not every 2.0 provider adapter keeps a reasoning_details array of its
+    # own. Where none was kept there is still #thinking, and 2.0 names the
+    # model #model where 1.x named it #model_id.
+    m = fake_message.new(role: :assistant, content: "done")
+    m.define_singleton_method(:thinking) { fake_thinking.new(text: "thought", signature: "sig-1") }
+    m.define_singleton_method(:model) { "anthropic/claude-sonnet-4" }
+    m.define_singleton_method(:raw_reasoning) { nil }
+
+    reasoning = Brute::MessageTransport::RubyLLM::V2.new(m).wrap_each.to_a.first.reasoning
+    reasoning.text.should == "thought"
+    reasoning.blocks.first.format.should == "anthropic/claude-sonnet-4"
   end
 end

data/lib/brute/messages.rb

@@ -22,6 +22,44 @@ module Brute
   #     Brute::ToolCall.new(id: "tc1", name: "shell", arguments: { "command" => "ls" }),
   #   ])
   #   Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
+  # One block of thinking. :text is what the model thought and :summary is
+  # the provider's precis of it; :encrypted is a payload that is not ours to
+  # read and matters only in that it goes back whole.
+  #
+  # Anthropic calls that payload redacted_thinking and OpenRouter calls the
+  # same thing reasoning.encrypted, so :redacted is taken as a spelling of
+  # :encrypted rather than a second kind -- a conversation logged through
+  # one and replayed to the other has to arrive as what it is.
+  ReasoningBlock = Data.define(
+    :type,
+    :text,
+    :signature,
+    :format,
+    :id,
+    :index,
+  ) do
+    TYPES = { redacted: :encrypted }.freeze
+
+    def initialize(type: :text, text: nil, signature: nil, format: nil, id: nil, index: nil)
+      type = type.to_sym
+
+      super(
+        type:      TYPES.fetch(type, type),
+        text:      text,
+        signature: signature,
+        format:    format,
+        id:        id,
+        index:     index,
+      )
+    end
+
+    def opaque? = type == :encrypted
+
+    def signed? = !signature.to_s.empty?
+
+    def to_h(...) = super.compact
+  end
+
   # What the model thought before it answered, and the provider's proof that
   # it did.
   #
@@ -40,10 +78,10 @@ module Brute
   # blocks must match the outputs generated by the model" (OpenRouter).
   Reasoning = Data.define(:blocks) do
     def self.build(text: nil, signature: nil, format: nil, blocks: nil)
-      blocks = Array(blocks).map { |block| block.is_a?(Reasoning::Block) ? block : Reasoning::Block.new(**block.to_h.transform_keys(&:to_sym)) }
+      blocks = Array(blocks).map { |block| block.is_a?(ReasoningBlock) ? block : ReasoningBlock.new(**block.to_h.transform_keys(&:to_sym)) }
 
       if blocks.empty? && !(text.to_s.empty? && signature.to_s.empty?)
-        blocks = [ Reasoning::Block.new(text: text, signature: signature, format: format) ]
+        blocks = [ ReasoningBlock.new(text: text, signature: signature, format: format) ]
       end
 
       unless blocks.empty?
@@ -85,46 +123,6 @@ module Brute
     def to_h(...) = { blocks: blocks.map(&:to_h) }
   end
 
-  class Reasoning
-    # One block of thinking. :text is what the model thought and :summary is
-    # the provider's precis of it; :encrypted is a payload that is not ours to
-    # read and matters only in that it goes back whole.
-    #
-    # Anthropic calls that payload redacted_thinking and OpenRouter calls the
-    # same thing reasoning.encrypted, so :redacted is taken as a spelling of
-    # :encrypted rather than a second kind -- a conversation logged through
-    # one and replayed to the other has to arrive as what it is.
-    Block = Data.define(
-      :type,
-      :text,
-      :signature,
-      :format,
-      :id,
-      :index,
-    ) do
-      TYPES = { redacted: :encrypted }.freeze
-
-      def initialize(type: :text, text: nil, signature: nil, format: nil, id: nil, index: nil)
-        type = type.to_sym
-
-        super(
-          type:      TYPES.fetch(type, type),
-          text:      text,
-          signature: signature,
-          format:    format,
-          id:        id,
-          index:     index,
-        )
-      end
-
-      def opaque? = type == :encrypted
-
-      def signed? = !signature.to_s.empty?
-
-      def to_h(...) = super.compact
-    end
-  end
-
   Message = Data.define(
     :role,
     :content,

data/lib/brute/version.rb

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

metadata

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