brute 6.0.2 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4197c46dd001a197da4f187e2729c21dc462355def0d458deb3a6341196fec67
-  data.tar.gz: 27453e69fbeff9fa2958502ea366843466c9347335127f593b76f2cd60ea1629
+  metadata.gz: a640b2c8ee7c0ca3d79e5618b3026494e48115c4bc38799e2d1ba1ca1acc968f
+  data.tar.gz: 66fed78b88d735cc528669e08dca7edbebfd1e6ba712f079fde45d268c9a5ec2
 SHA512:
-  metadata.gz: bcb85717124bd3b7f4272eb7809a51d240adbcb1ad27aff3e5b67de53b4b1088ba14d7becdeb658b349f350f5247c82119c6e024799ab36ffc38f7fd74630ddf
-  data.tar.gz: 46dbd653dbde8e6edea254440b6b793d99766567402164181e7c4b9b780ed28aa85602a6ae8033febedb5858a75659278b69878782beab0a10d30ee9d8ec7668
+  metadata.gz: a5374a6f3194a224069e812c3d49ef0748ca1e6b03d13ea0ef5e645103e6d67ec08f92f4702a86bce78733844c59472a571b9012268759e1a92693ce61b12b83
+  data.tar.gz: aab38ce15e5fec92937cdef94a9350e880cf0ab52bce6e1706ed586fc720c204b94a8ca98e4021dce069a0ae058447194e615d6c8c29990debcd30f88a0a6907

data/lib/brute/completion/open_router.rb

@@ -46,7 +46,7 @@ module Brute
         env.emit_trace do |env|
           env.emit(LLM_START_EVENT)
 
-          messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages])
+          messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages], model: options(env).model)
 
           ::OpenRouter::Client.new(**@config).then do |client|
             response = nil

data/lib/brute/hooks.rb

@@ -70,7 +70,9 @@ module Brute
       # The trace this one was opened inside, if any: emit_trace wraps, so the
       # thing wrapped is the call that was already running.
       def parent
-        __getobj__ if __getobj__.is_a?(Trace)
+        if __getobj__.is_a?(Trace)
+          __getobj__
+        end
       end
 
       def emit(event, *extras, &work) = @hooks.emit(

data/lib/brute/message_transport/anthropic.rb

@@ -28,6 +28,9 @@ module Brute
     # a user message — consecutive tool results are folded into one user
     # turn so roles keep alternating.
     class Anthropic < MessageTransport
+      # 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"
       # The :system messages' text, for the top-level `system_:` parameter.
       def self.system_text(messages)
         messages.select { |m| m.role == :system }.map(&:content).join("\n\n")
@@ -35,7 +38,7 @@ module Brute
 
       # Brute log -> the `messages:` array. Drops :system messages (see
       # .system_text) and folds consecutive :tool results into one user turn.
-      def self.dump_all(messages)
+      def self.dump_all(messages, model: nil)
         chat = messages.reject { |m| m.role == :system }
 
         chat.chunk_while { |a, b| a.role == :tool && b.role == :tool }.map do |group|
@@ -48,26 +51,75 @@ module Brute
       end
 
       # Brute::Message -> an Anthropic message param hash.
-      def self.dump(message)
+      def self.dump(message, model: nil)
         case message.role
         when :tool
           { role: "user", content: [tool_result_block(message)] }
         when :assistant
           if message.tool_call?
-            blocks = []
+            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
-            { role: "assistant", content: message.content }
+            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
         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.
+      def self.expressible?(reasoning)
+        reasoning.blocks.all? { |block| block.type == :text || block.opaque? }
+      end
+
+      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
+        else
+          []
+        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)
+        when :redacted_thinking
+          Brute::Reasoning::Block.new(type: :encrypted, signature: block.data, format: FORMAT)
+        end
+      end
+
       def self.tool_result_block(message)
         { type: "tool_result", tool_use_id: message.tool_call_id, content: message.content.to_s }
       end
@@ -80,6 +132,12 @@ module Brute
           blocks = message.content
 
           text = blocks.select { |b| b.type == :text }.map(&:text).join
+
+          # Thinking is its own block, its signature is what the API checks
+          # when it comes back, and redacted thinking is a block whose payload
+          # is not ours to read. All of them are kept, in order: what goes back
+          # has to match what the model produced.
+          thinking = blocks.filter_map { |b| self.class.thinking_block(b) }
           tool_calls = blocks.select { |b| b.type == :tool_use }.map do |b|
             if b.input.respond_to?(:to_h)
               arguments = b.input.to_h
@@ -97,6 +155,7 @@ module Brute
             role:       :assistant,
             content:    text,
             tool_calls: tool_calls,
+            reasoning:  Brute::Reasoning.build(blocks: thinking),
           )
         end
     end
@@ -140,6 +199,52 @@ describe "brute/message_transport/anthropic" do
     dumped.last[:content].map { |b| b[:tool_use_id] }.should == %w[tc1 tc2]
   end
 
+  it "sends signed thinking back first, ahead of the text" do
+    # The sequence is part of what is verified, so thinking leads.
+    m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+      blocks: [{ type: :text, text: "let me think", signature: "sig-1", format: "anthropic-claude-v1" }],
+    })
+
+    Brute::MessageTransport::Anthropic.dump(m)[:content].should == [
+      { type: "thinking", thinking: "let me think", signature: "sig-1" },
+      { type: "text", text: "done" },
+    ]
+  end
+
+  it "sends an opaque payload home as redacted_thinking, under either name" do
+    # Anthropic calls it redacted_thinking; OpenRouter calls the same Claude
+    # payload reasoning.encrypted. A conversation logged through either one
+    # goes back the same way.
+    [:redacted, :encrypted].each do |type|
+      m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+        blocks: [{ type: type, signature: "blob", format: "anthropic-claude-v1" }],
+      })
+
+      Brute::MessageTransport::Anthropic.dump(m)[:content].first
+        .should == { type: "redacted_thinking", data: "blob" }
+    end
+  end
+
+  it "sends no thinking at all rather than a block it cannot vouch for" do
+    # An unverifiable block is a 400, and no thinking beats a failed request:
+    # a signature Anthropic did not issue, and a block carrying none where it
+    # requires one, are both refused -- and refused whole.
+    foreign = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+      blocks: [{ type: :text, text: "thought", signature: "sig-1", format: "openai-responses-v1" }],
+    })
+
+    partly_signed = 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",                     format: "anthropic-claude-v1" },
+      ],
+    })
+
+    [foreign, partly_signed].each do |m|
+      Brute::MessageTransport::Anthropic.dump(m)[:content].should == [{ type: "text", text: "done" }]
+    end
+  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/llm.rb

@@ -27,7 +27,7 @@ module Brute
       # `original_tool_calls` extra (the provider wire format); tool results
       # become an LLM::Function::Return so llm.rb's request adapters emit
       # them correctly.
-      def self.dump(message)
+      def self.dump(message, model: nil)
         case message.role
         when :tool
           ::LLM::Message.new(
@@ -67,8 +67,16 @@ module Brute
             role:       message.role,
             content:    message.content.to_s,
             tool_calls: tool_calls,
+            reasoning:  reasoning(message),
           )
         end
+
+        # llm.rb hangs it off the message's extras as reasoning_content.
+        def reasoning(message)
+          if message.respond_to?(:reasoning_content)
+            Brute::Reasoning.build(text: message.reasoning_content)
+          end
+        end
     end
   end
 end

data/lib/brute/message_transport/open_router.rb

@@ -13,14 +13,90 @@ 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.
       def self.usage_metrics(response)
         Brute::UsageDetection::OpenRouter.detect(response)
       end
-      def self.dump(message)
-        message.to_h
+      # 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 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.
+      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
+
+            # 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
+          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
+      # is simply lost, which for an encrypted item is the whole of it.
+      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
+          named.merge(text: block.text, signature: block.signature).compact
+        end
       end
 
       # An OpenRouter::Response's messages (one per choice; in practice
@@ -47,8 +123,18 @@ module Brute
 
           case hash
           in { role: (:system | :user | :assistant | :tool) }
-            # Slice away provider extras (refusal, reasoning, model, ...)
-            # that Brute::Message doesn't know.
+            # 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.
             Brute::Message.new(
               **hash.slice(
                 :role,
@@ -56,12 +142,48 @@ module Brute
                 :tool_calls,
                 :tool_call_id,
               ),
+              reasoning: reasoning(hash),
             )
           else
             raise "Unrecognised message format #{message.inspect}"
           end
         end
 
+        # reasoning_details is the sequence the model produced, each detail
+        # naming its own format; `reasoning` is the same thing as plaintext.
+        def reasoning(hash)
+          details = Array(hash[:reasoning_details]).map { |detail| detail.to_h.transform_keys(&:to_sym) }
+
+          if details.empty?
+            Brute::Reasoning.build(text: hash[:reasoning])
+          else
+            Brute::Reasoning.build(blocks: details.map { |detail| block(detail) })
+          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(
+            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,
+            id:        detail[:id],
+            index:     detail[:index],
+          )
+        end
+
         # An OpenAI-wire tool call ({ id:, type:, function: { name:, arguments: JSON } })
         # -> the flat { id:, name:, arguments: Hash } Brute::Message understands.
         def wrap_tool_call(tool_call)
@@ -105,6 +227,117 @@ 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
+    # 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.
+    thought = Struct.new(:choices).new([{ "message" => { "role" => "assistant", "content" => "", "reasoning" => "thought about it" } }])
+
+    reasoned = Brute::MessageTransport::OpenRouter.new(thought).wrap_each.to_a.first
+    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 = 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[:reasoning_details].should == [
+      { type: "reasoning.text", format: "anthropic/claude-sonnet-4", 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
+    # OpenRouter names each payload after its type: a summary's prose is
+    # `summary`, an encrypted item's payload is `data`, and only reasoning
+    # text carries a `signature`. Read or written under the wrong key, the
+    # payload is simply lost -- and an encrypted item is the case where the
+    # plaintext alone is not enough.
+    details = [
+      { "type" => "reasoning.text", "text" => "step by step", "signature" => "sig-1",
+        "format" => "anthropic-claude-v1", "id" => "r-1", "index" => 0 },
+      { "type" => "reasoning.summary", "summary" => "weighed the constraints",
+        "format" => "anthropic-claude-v1", "id" => "r-2", "index" => 1 },
+      { "type" => "reasoning.encrypted", "data" => "b64blob",
+        "format" => "anthropic-claude-v1", "id" => "r-3", "index" => 2 },
+    ]
+
+    response = Struct.new(:choices).new([
+      { "message" => { "role" => "assistant", "content" => "", "reasoning_details" => details } },
+    ])
+
+    wrapped = Brute::MessageTransport::OpenRouter.new(response).wrap_each.to_a.first
+    wrapped.reasoning.text.should == "step by step\nweighed the constraints"
+
+    back = Brute::MessageTransport::OpenRouter.dump(wrapped, model: "anthropic/claude-sonnet-4")
+    back[:reasoning_details].should == details.map { |detail| detail.transform_keys(&:to_sym) }
+  end
+
+  it "sends an opaque payload out as reasoning.encrypted, under either name" do
+    # The same Claude payload is :redacted when Anthropic logged it and
+    # :encrypted when OpenRouter did. Either way it is not text, and its
+    # payload belongs under data.
+    [:redacted, :encrypted].each do |type|
+      m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+        blocks: [{ type: type, signature: "b64blob", format: "anthropic-claude-v1" }],
+      })
+
+      Brute::MessageTransport::OpenRouter.dump(m, model: "anthropic/claude-sonnet-4")[:reasoning_details]
+        .should == [{ type: "reasoning.encrypted", data: "b64blob", format: "anthropic-claude-v1" }]
+    end
+  end
+
+  it "sends the details sequence whole, or not at all" 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.
+    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" },
+      ] } },
+    ])
+
+    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
+  end
+
+  it "does not invent a details sequence around plaintext reasoning" do
+    # A sequence Brute made up is not one the model produced.
+    plain = Brute::Message.new(role: :assistant, content: "done", reasoning: "just thinking")
+
+    back = Brute::MessageTransport::OpenRouter.dump(plain, model: "anthropic/claude-sonnet-4")
+    back[:reasoning].should == "just thinking"
+    back.key?(:reasoning_details).should.be.false
+  end
+
   it "unwraps OpenAI-wire tool calls and parses their JSON arguments" do
     fake_response = Struct.new(:choices).new([
       { "message" => {

data/lib/brute/message_transport/openai.rb

@@ -22,7 +22,11 @@ module Brute
     #   Brute::MessageTransport::OpenAI.wrap_each(response) { |m| env[:messages] << m }
     class OpenAI < MessageTransport
       # Brute::Message -> a chat.completions message param hash.
-      def self.dump(message)
+      # Chat completions has no field for reasoning -- neither
+      # ChatCompletionMessage nor the assistant message param carries one --
+      # so nothing is sent back here. Reasoning items belong to the Responses
+      # API, which this transport does not speak.
+      def self.dump(message, model: nil)
         case message.role
         when :tool
           { role: "tool", tool_call_id: message.tool_call_id, content: message.content.to_s }

data/lib/brute/message_transport/ruby_llm.rb

@@ -15,7 +15,7 @@ module Brute
       end
 
       # Brute::Message -> RubyLLM::Message (tool calls as ruby_llm's id-keyed hash).
-      def self.dump(message)
+      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)]
         end
@@ -25,9 +25,22 @@ module Brute
           content:      message.content,
           tool_calls:   tool_calls,
           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.
+      def self.thinking(message)
+        if message.reasoning
+          ::RubyLLM::Thinking.build(
+            text:      message.reasoning.text,
+            signature: message.reasoning.blocks.find(&:signed?)&.signature,
+          )
+        end
+      end
+
       private
 
       # RubyLLM::Message -> Brute::Message.
@@ -52,8 +65,29 @@ module Brute
             content:      message.content&.to_s, # Preserves nil safely
             tool_calls:   tool_calls,
             tool_call_id: message.tool_call_id,
+            reasoning:    reasoning(message),
           )
         end
+
+        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.
+        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),
+            )
+          end
+        end
     end
   end
 end
@@ -75,6 +109,34 @@ describe "brute/message_transport/ruby_llm" do
     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"
+
+    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.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)
+    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" }
+
+    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"
+  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 })

data/lib/brute/message_transport/ruby_open_ai.rb

@@ -3,7 +3,9 @@ module Brute
     class RubyOpenAI < MessageTransport
 
       # Brute::Message -> ruby-openai Hash payload
-      def self.dump(message)
+      # An OpenAI-compatible proxy may report reasoning, and it is read on the
+      # way in, but the chat completions wire has no field to send it back on.
+      def self.dump(message, model: nil)
         {
           role: message.role.to_s,
         }.tap do |payload|
@@ -67,13 +69,15 @@ module Brute
               role:       :assistant,
               content:    hash[:content],
               tool_calls: tool_calls,
+              reasoning:  hash[:reasoning],
             )
 
           # Branch 3: Standard Assistant text message
           in { role: "assistant" }
             Brute::Message.new(
-              role:    :assistant,
-              content: hash[:content],
+              role:      :assistant,
+              content:   hash[:content],
+              reasoning: hash[:reasoning],
             )
 
           else

data/lib/brute/message_transport.rb

@@ -12,13 +12,17 @@ module Brute
     end
 
     #  Outbound: one Brute::Message in the library's format. Identity here.
-    def self.dump(message)
+    #
+    # `model:` is what the turn is about to be sent to. A transport that puts
+    # signed reasoning back on the wire needs it: a signature is only valid
+    # against the provider that issued it, and the log outlives any one model.
+    def self.dump(message, model: nil)
       message
     end
 
     # Outbound: the whole log in the library's format.
-    def self.dump_all(messages)
-      messages.map { |message| dump(message) }
+    def self.dump_all(messages, model: nil)
+      messages.map { |message| dump(message, model: model) }
     end
 
     # Inbound: what the provider reported about this call, as a

data/lib/brute/messages.rb

@@ -22,13 +22,117 @@ module Brute
   #     Brute::ToolCall.new(id: "tc1", name: "shell", arguments: { "command" => "ls" }),
   #   ])
   #   Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
+  # What the model thought before it answered, and the provider's proof that
+  # it did.
+  #
+  # A signature is only meaningful to the provider that issued it: Anthropic
+  # verifies its own and rejects a modified block with a 400, and OpenRouter
+  # names the format ("anthropic-claude-v1", "openai-responses-v1") because
+  # the details only mean anything against the provider that produced them.
+  # The log is provider-agnostic and a conversation can be replayed against
+  # anyone, so what was signed carries who signed it -- a transport sends the
+  # blocks back only when they are its own, and sends the text alone when they
+  # are not.
+  #
+  # The blocks are a sequence, in the order the model produced them, because
+  # that is what both providers ask for: "passed back unmodified and in their
+  # original order" (Anthropic), "the entire sequence of consecutive reasoning
+  # 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)) }
+
+      if blocks.empty? && !(text.to_s.empty? && signature.to_s.empty?)
+        blocks = [ Reasoning::Block.new(text: text, signature: signature, format: format) ]
+      end
+
+      unless blocks.empty?
+        new(blocks: blocks)
+      end
+    end
+
+    # 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
+
+  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,
     :tool_calls,
     :tool_call_id,
+    :reasoning,
   ) do
-    def initialize(role:, content: nil, tool_calls: nil, tool_call_id: nil)
+    def initialize(role:, content: nil, tool_calls: nil, tool_call_id: nil, reasoning: nil)
       formatted_calls = tool_calls&.map do |tc|
         tc.is_a?(ToolCall) ? tc : ToolCall.new(**tc.to_h.transform_keys(&:to_sym))
       end
@@ -37,7 +141,8 @@ module Brute
         role:         role.to_sym,
         content:      content,
         tool_calls:   formatted_calls,
-        tool_call_id: tool_call_id
+        tool_call_id: tool_call_id,
+        reasoning:    coerce(reasoning)
       )
     end
 
@@ -50,8 +155,23 @@ module Brute
       if tool_calls
         hash[:tool_calls] = tool_calls.map(&:to_h)
       end
+      if reasoning
+        hash[:reasoning] = reasoning.to_h
+      end
       hash.compact
     end
+
+    private
+
+      # Reasoning read back off disk is a hash, and a provider that reports
+      # nothing but the text is still reporting reasoning.
+      def coerce(reasoning)
+        case reasoning
+        in nil | Reasoning then reasoning
+        in String => text then Reasoning.build(text: text)
+        else Reasoning.build(**reasoning.to_h.transform_keys(&:to_sym))
+        end
+      end
   end
 
   # The in-memory conversation log is just a plain Array of Brute::Message.
@@ -129,4 +249,47 @@ describe "brute/messages" do
   it "to_h drops nil fields" do
     Brute::Message.new(role: :user, content: "hi").to_h.should == { role: :user, content: "hi" }
   end
+
+  it "round-trips reasoning through to_h" do
+    m = Brute::Message.new(role: :assistant, content: "done", reasoning: {
+      blocks: [{ type: :text, text: "thought", signature: "sig-1", format: "anthropic-claude-v1" }],
+    })
+
+    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.
+    Brute::Reasoning.build(text: "just thinking").detailed?.should.be.false
+
+    Brute::Reasoning.build(blocks: [
+      { type: :summary, text: "considered it", format: "anthropic-claude-v1", id: "r-1" },
+    ]).detailed?.should.be.true
+  end
 end

data/lib/brute/version.rb

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

metadata

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