brute 6.0.2 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4197c46dd001a197da4f187e2729c21dc462355def0d458deb3a6341196fec67
-  data.tar.gz: 27453e69fbeff9fa2958502ea366843466c9347335127f593b76f2cd60ea1629
+  metadata.gz: a29376e6820e2ef4e6233073f2012ff95541027b64307956e141af222ece973e
+  data.tar.gz: 94c6351c5526249d3a62d200050180d4880f92bfbe259f3c97fabe5e5663160a
 SHA512:
-  metadata.gz: bcb85717124bd3b7f4272eb7809a51d240adbcb1ad27aff3e5b67de53b4b1088ba14d7becdeb658b349f350f5247c82119c6e024799ab36ffc38f7fd74630ddf
-  data.tar.gz: 46dbd653dbde8e6edea254440b6b793d99766567402164181e7c4b9b780ed28aa85602a6ae8033febedb5858a75659278b69878782beab0a10d30ee9d8ec7668
+  metadata.gz: a156cb8659d03cf076b359a2e14e7d462d456433aa5b3a169ec1fcef97b775132ede29b7b838246a2237f32cc5c7e927df513391df61c8e726d14f4101195a5c
+  data.tar.gz: '008a7f1f998bd58467fa13769318d32d27e1d6e92808619dd3a7baed8c3444b263e935a3a435a87405849bab3a7c2ae691a7f0866475b544e6210a61b4215a19'

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,13 @@ 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"
       # 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 +42,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 +55,92 @@ 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)] }
+          { role: "user", content: [ tool_result_block(message) ] }
         when :assistant
-          if message.tool_call?
-            blocks = []
-            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 }
-          end
+          { role: "assistant", content: assistant_content(message) }
         else
           { role: message.role.to_s, content: message.content }
         end
       end
 
+      # 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.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 && 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::ReasoningBlock.new(type: :text, text: block.thinking, signature: block.signature, format: FORMAT)
+        when :redacted_thinking
+          Brute::ReasoningBlock.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 +153,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 +176,7 @@ module Brute
             role:       :assistant,
             content:    text,
             tool_calls: tool_calls,
+            reasoning:  Brute::Reasoning.build(blocks: thinking),
           )
         end
     end
@@ -140,6 +220,73 @@ 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 "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/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,61 @@ 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
+      # 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.
+      #
+      # 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)
+
+          reasoning = message.reasoning
+
+          if reasoning&.detailed?
+            hash[:reasoning_details] = reasoning.blocks.map { |block| detail(block) }
+          elsif reasoning && !reasoning.text.empty?
+            hash[:reasoning] = reasoning.text
+          end
+        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 +94,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 +113,43 @@ 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
+
+        # 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::ReasoningBlock.new(
+            type:      type.empty? ? :text : type.to_sym,
+            text:      detail[:text] || detail[:summary],
+            signature: detail[:signature] || detail[:data],
+            # 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],
+          )
+        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 +193,148 @@ 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, 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.key?(:reasoning).should.be.false
+    back[:reasoning_details].should == [
+      { 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
+    # 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 "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." 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", "index" => 0 },
+        { "type" => "reasoning.encrypted", "data" => "b64blob",
+          "format" => "anthropic-claude-v1", "index" => 1 },
+      ] } },
+    ])
+
+    wrapped = Brute::MessageTransport::OpenRouter.new(response).wrap_each.to_a.first
+
+    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
+    # 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

@@ -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,37 +57,26 @@ 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)
-        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
-
-        ::RubyLLM::Message.new(
-          role:         message.role,
-          content:      message.content,
-          tool_calls:   tool_calls,
-          tool_call_id: message.tool_call_id,
-        )
       end
 
       private
 
-      # RubyLLM::Message -> Brute::Message.
+        # 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
+          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,
-            )
+            Brute::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments)
           end
 
           Brute::Message.new(
@@ -52,6 +84,171 @@ 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
+
+        # 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(message),
+          tool_call_id: message.tool_call_id,
+          thinking:     thinking(message),
+        )
+      end
+
+      # 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)
+        reasoning = message.reasoning
+
+        if reasoning&.blocks&.one?
+          block = reasoning.blocks.first
+
+          ::RubyLLM::Thinking.build(
+            text:      block.text.to_s.empty? ? nil : block.text,
+            signature: block.signature,
+          )
+        end
+      end
+
+      private
+
+        # 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
+          named.merge(text: block.text, signature: block.signature).compact
+        end
+      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
+
+        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
+
+        # The reasoning_details sequence where the adapter kept one, and
+        # ruby_llm's flattened view where it did not.
+        def reasoning(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
@@ -62,15 +259,33 @@ __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
@@ -79,7 +294,109 @@ describe "brute/message_transport/ruby_llm" 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.new(m).wrap_each.to_a.first
+    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::V1.dump(m).thinking
+    thinking.text.should == "thought it through"
+    thinking.signature.should == "sig-1"
+  end
+
+  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(:raw_reasoning) { details }
+
+    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 "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")
+
+    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/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,115 @@ 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.
+  #
+  # 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?(ReasoningBlock) ? block : ReasoningBlock.new(**block.to_h.transform_keys(&:to_sym)) }
+
+      if blocks.empty? && !(text.to_s.empty? && signature.to_s.empty?)
+        blocks = [ ReasoningBlock.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
+
   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 +139,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 +153,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 +247,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.1"
 end

metadata

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