riffer 0.49.0 → 0.50.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1bd95697d75079325d4a057c0f2bb17bc8fee9a3864c611967e78d8e1637ef8
-  data.tar.gz: 84ddb8c10cef0b5711b00793b3a19de2713fcf8d7985166dfaa248fa7bbe58f0
+  metadata.gz: 1700c8028d7de9b0e109fc259f904c8a8ff1e92964e23c90cd00574cd43a0bc2
+  data.tar.gz: 1245b96f6a1490aa5cedd3d5e60ff062a8d70cc7330bd7ec01d0f027e05d65fa
 SHA512:
-  metadata.gz: 375f9c10e95e1dbd60da4acd0209bdc5707a30dff00e742815fb874cb00755b187602967433d5677444e790b9d94153c1408e9bc8f91a80e5879aa696de0a550
-  data.tar.gz: a05871a1bcd23100fa5d0018438810476560c19f87e82ebaaa6b7322e81b03577f12923845716792deb479c86f59a49127e65b2f862f4a84b95e11d75a6cb942
+  metadata.gz: dc40857b3085259180f014442cd8d2ec4c6f6f85d2c577cacbff6332176eb39e948de9e20b22732730e52ea4151016fcf23c3387de181f8b8ff27537df8cc21f
+  data.tar.gz: '0152801a535973a01216aac4ff1a5b07554b2e8bde282a9dd3fc2c09408b0ddb7890953e7d60c21102d0889896190adf88d6822ef0ca0ff4a6564b688f7b4dd2'

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.49.0"
+  ".": "0.50.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.50.0](https://github.com/janeapp/riffer/compare/riffer/v0.49.0...riffer/v0.50.0) (2026-09-28)
+
+
+### Features
+
+* **anthropic:** capture and replay thinking blocks ([#463](https://github.com/janeapp/riffer/issues/463)) ([4a25851](https://github.com/janeapp/riffer/commit/4a25851141cb9b859778e38e58d701cbfe72939f))
+* **open_ai:** capture and replay reasoning items ([#464](https://github.com/janeapp/riffer/issues/464)) ([03d54a9](https://github.com/janeapp/riffer/commit/03d54a90547797a8c56321527fd73ae1d3b9becc))
+
+
+### Bug Fixes
+
+* **providers:** keep every text block in assistant content ([#468](https://github.com/janeapp/riffer/issues/468)) ([db14e7a](https://github.com/janeapp/riffer/commit/db14e7ac35bd764c1efa7eb2c7bea95c8050a984))
+
 ## [0.49.0](https://github.com/janeapp/riffer/compare/riffer/v0.48.0...riffer/v0.49.0) (2026-09-27)
 
 

data/docs/STREAM_EVENTS.md

@@ -53,7 +53,7 @@ event.content  # => "Hello, how can I help you?"
 event.to_h     # => {role: :assistant, content: "Hello, how can I help you?"}
 ```
 
-Contains the complete final text.
+Fires once per model response, after its last `TextDelta`, and contains the response's full text: every text block the provider returned, concatenated in order, so it always equals the joined `TextDelta` contents. A response that carries no text (for example, only tool calls) emits no `TextDone`.
 
 ### ToolCallDelta
 
@@ -303,8 +303,8 @@ end
 
 When an agent uses tools during streaming, the flow is:
 
-1. Text events stream in (`TextDelta`, `TextDone`)
-2. If tool calls are present: `ToolCallDelta` events, then `ToolCallDone`
+1. `TextDelta`, `ToolCallDelta` and `ToolCallDone` events stream in, in whatever order the model produces them. Text can come before, between or after tool calls.
+2. If the response contained any text, one `TextDone` follows with the full text. A response that only calls tools has no `TextDone`.
 3. Agent executes tools internally
 4. Agent sends results back to LLM
 5. More text events stream in

data/docs/providers/ANTHROPIC.md

@@ -187,6 +187,16 @@ agent.stream("Solve this complex math problem").each do |event|
 end
 ```
 
+The reasoning is kept on the assistant message as [reasoning parts](../MESSAGES.md#reasoning), whether you call `generate` or `stream`. Read it with `response.reasoning`, or as plain text with `reasoning_text` on the message. Each `thinking` block becomes a `:text` part carrying its `signature`, and each `redacted_thinking` block becomes an `:encrypted` part whose `data` is the block's opaque payload. `reasoning_text` leaves the redacted parts out, since they have no readable text. Every part is tagged `format: "anthropic-messages-v1"` (`Riffer::Providers::Anthropic::REASONING_FORMAT`).
+
+### Reasoning Replay
+
+Riffer sends the reasoning back to Anthropic on every later turn, as `thinking` and `redacted_thinking` blocks ahead of the message's text and `tool_use` blocks, in their original order and unchanged. For tool calls, sending it back is required: when thinking is enabled, Claude needs its earlier thinking blocks back to carry on after a tool result. You don't have to do anything; it happens as long as the assistant messages stay in the history.
+
+If you persist sessions, keep the `reasoning` key when you store messages (see [Messages — Reasoning](../MESSAGES.md#reasoning)). If you drop it, later turns lose the model's earlier reasoning, and a tool-calling turn with thinking enabled may be rejected.
+
+Only reasoning that this provider produced is sent back to Anthropic. A conversation that switches providers midway still works: reasoning from other providers (including OpenRouter's `anthropic-claude-v1` parts) is kept on the messages but left out of Anthropic requests.
+
 ## Web Search
 
 Web search allows Claude to search the web for up-to-date information. When enabled, the provider injects the `web_search_20250305` server tool into the request.

data/docs/providers/AZURE_OPENAI.md

@@ -87,6 +87,8 @@ Enables extended thinking (for supported models):
 model_options reasoning: 'medium'  # 'low', 'medium', or 'high'
 ```
 
+Reasoning is captured and replayed on later turns exactly as with the [OpenAI provider](OPENAI.md#reasoning-replay), except that parts are tagged `format: "azure-openai-v1"`. Azure only accepts reasoning produced by the same resource, so parts from the OpenAI provider are never sent to Azure, and Azure's are never sent to OpenAI.
+
 ### structured_output
 
 Structured JSON output works identically to the OpenAI provider.

data/docs/providers/OPENAI.md

@@ -82,6 +82,28 @@ model_options reasoning: 'medium'  # 'low', 'medium', or 'high'
 
 When reasoning is enabled, you'll receive `ReasoningDelta` and `ReasoningDone` events during streaming.
 
+#### Reasoning Replay
+
+Each `reasoning` item in a Responses API output becomes [reasoning parts](../MESSAGES.md#reasoning) on the assistant message, on both `generate_text` and `stream_text`, all tagged `format: "openai-v1"` and carrying the item's `id`:
+
+| Reasoning item field | `ReasoningPart`                         |
+| -------------------- | --------------------------------------- |
+| each `summary` entry | a `:summary` part with its `text`       |
+| each `content` entry | a `:text` part with its `text`          |
+| `encrypted_content`  | one `:encrypted` part with it as `data` |
+
+The `:encrypted` part is always present, even when the response carried no `encrypted_content`, so the item's `id` is kept. When streaming, the parts are yielded as `ReasoningDone` events once the item completes; summary text still arrives as `ReasoningDelta` events before that.
+
+On the next request, parts sharing an `id` go back as one `reasoning` item, ahead of the assistant's text and function calls, in their original order and unchanged. This lets reasoning models carry their reasoning across turns and tool-call loops. You don't have to do anything as long as the assistant messages stay in the history; if you persist sessions, keep the `reasoning` key when you store them.
+
+With `store` left on (the API default), OpenAI can resolve a replayed item from its `id` alone. With `model_options store: false`, the item can only be replayed from its encrypted payload, so request it explicitly:
+
+```ruby
+model_options reasoning: 'medium', store: false, include: ['reasoning.encrypted_content']
+```
+
+Only parts tagged `openai-v1` are sent. Reasoning from other providers stays on the messages but is left out, including OpenRouter's `openai-responses-v1` parts, which are encrypted under OpenRouter's organization rather than yours.
+
 ### web_search
 
 Enable server-side web search using OpenAI's `web_search_preview` tool. Pass `true` to use defaults or a hash to merge with the tool definition:

data/lib/riffer/providers/amazon_bedrock.rb

@@ -298,11 +298,11 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
           handle_content_block_delta_tool_use(event, state: current_state, yielder: yielder) if event.delta&.tool_use
           handle_reasoning_delta(event, state: current_state, yielder: yielder) if event.delta&.reasoning_content
         when Aws::BedrockRuntime::Types::ContentBlockStopEvent
-          handle_content_block_stop_text_delta(event, state: current_state, yielder: yielder) if current_state[:text]
           handle_content_block_stop_tool_use(event, state: current_state, yielder: yielder) if current_state[:tool_call]
           handle_reasoning_stop(event, state: current_state, yielder: yielder) if current_state[:reasoning]
         when Aws::BedrockRuntime::Types::MessageStopEvent
           stream_completed = true
+          yielder << Riffer::StreamEvents::TextDone.new(current_state[:text]) if current_state[:text]
           yield_finish_reason(yielder, build_finish_reason(event.stop_reason))
         when Aws::BedrockRuntime::Types::ConverseStreamMetadataEvent
           handle_metadata_usage(event, state: current_state, yielder: yielder) if event.usage
@@ -362,7 +362,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     typed_event = event #: Aws::BedrockRuntime::Types::ContentBlockDeltaEvent
     delta_text = typed_event.delta.text
     # << avoids += copying the whole buffer per delta (O(n^2)); safe because
-    # nothing reads the pre-append string before block stop clears it.
+    # nothing reads the buffer before message stop hands it to TextDone.
     state[:text] ||= +""
     state[:text] << delta_text
     yielder << Riffer::StreamEvents::TextDelta.new(delta_text)
@@ -406,13 +406,6 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     state[:reasoning] = nil
   end
 
-  #--
-  #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_content_block_stop_text_delta(_event, state:, yielder:)
-    yielder << Riffer::StreamEvents::TextDone.new(state[:text])
-    state[:text] = nil
-  end
-
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_content_block_stop_tool_use(_event, state:, yielder:)

data/lib/riffer/providers/anthropic.rb

@@ -16,6 +16,11 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     "pause_turn" => :other,
   }.freeze #: Hash[String, Symbol]
 
+  # Only parts carrying this tag are replayed, so reasoning captured by another
+  # adapter, whose signatures the Messages API may not accept, never reaches the
+  # request.
+  REASONING_FORMAT = "anthropic-messages-v1" #: String
+
   #--
   #: (?String?) -> singleton(Riffer::Skills::Adapter)
   def self.skills_adapter(_model = nil)
@@ -153,16 +158,7 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   #: (untyped) -> String
   def extract_content(response)
     message = response #: Anthropic::Models::Message
-    content_blocks = message.content
-    return "" if content_blocks.nil? || content_blocks.empty?
-
-    text_content = ""
-
-    content_blocks.each do |block|
-      text_content = block.text if block.is_a?(::Anthropic::Models::TextBlock)
-    end
-
-    text_content
+    (message.content || []).filter_map { |block| block.text if block.is_a?(::Anthropic::Models::TextBlock) }.join
   end
 
   #--
@@ -187,12 +183,34 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     tool_calls
   end
 
+  #--
+  #: (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+  def extract_reasoning(response)
+    message = response #: Anthropic::Models::Message
+    (message.content || []).filter_map { |block| build_reasoning_part(block) }
+  end
+
+  #--
+  #: (untyped) -> Riffer::Messages::Assistant::ReasoningPart?
+  def build_reasoning_part(block)
+    case block
+    when ::Anthropic::Models::ThinkingBlock
+      Riffer::Messages::Assistant::ReasoningPart.new(
+        type: :text,
+        text: block.thinking,
+        signature: block.signature,
+        format: REASONING_FORMAT,
+      )
+    when ::Anthropic::Models::RedactedThinkingBlock
+      Riffer::Messages::Assistant::ReasoningPart.new(type: :encrypted, data: block.data, format: REASONING_FORMAT)
+    end
+  end
+
   #--
   #: (Hash[Symbol, untyped], Riffer::Providers::_EventSink) -> void
   def execute_stream(params, yielder)
     current_state = {
       text: nil,
-      reasoning: nil,
       tool_call: nil,
       web_search_index: nil,
       web_search_json: nil,
@@ -218,19 +236,15 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
         when ::Anthropic::Helpers::Streaming::TextEvent
           handle_text_event(event, state: current_state, yielder: yielder)
         when ::Anthropic::Helpers::Streaming::ThinkingEvent
-          handle_thinking_event(event, state: current_state, yielder: yielder)
+          yielder << Riffer::StreamEvents::ReasoningDelta.new(event.thinking)
         when ::Anthropic::Helpers::Streaming::InputJsonEvent
           handle_input_json_event(event, state: current_state, yielder: yielder)
         when ::Anthropic::Helpers::Streaming::ContentBlockStopEvent
           case event.content_block
-          when ::Anthropic::Models::TextBlock
-            handle_content_block_stop_text(event, state: current_state, yielder: yielder) if current_state[:text]
           when ::Anthropic::Models::ToolUseBlock
             handle_content_block_stop_tool_use(event, state: current_state, yielder: yielder)
-          when ::Anthropic::Models::ThinkingBlock
-            if current_state[:reasoning]
-              handle_content_block_stop_thinking(event, state: current_state, yielder: yielder)
-            end
+          when ::Anthropic::Models::ThinkingBlock, ::Anthropic::Models::RedactedThinkingBlock
+            handle_content_block_stop_reasoning(event, yielder: yielder)
           when ::Anthropic::Models::ServerToolUseBlock
             handle_content_block_stop_server_tool_use(event, state: current_state, yielder: yielder)
           when ::Anthropic::Models::WebSearchToolResultBlock
@@ -238,7 +252,9 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
           end
         when ::Anthropic::Helpers::Streaming::MessageStopEvent
           stream_completed = true
-          handle_message_stop(event, accumulated_message: stream.accumulated_message, yielder: yielder)
+          handle_message_stop(
+            event, state: current_state, accumulated_message: stream.accumulated_message, yielder: yielder,
+          )
         end
       end
     ensure
@@ -275,21 +291,13 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_text_event(event, state:, yielder:)
-    # Mutating append avoids O(n^2) copying per content block; the buffer is
-    # handed to TextDone and cleared on block stop, so no reader sees it mid-append.
+    # Mutating append avoids O(n^2) copying across the response; the buffer
+    # reaches TextDone only at message stop, so no reader sees it mid-append.
     state[:text] ||= +""
     state[:text] << event.text
     yielder << Riffer::StreamEvents::TextDelta.new(event.text)
   end
 
-  #--
-  #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_thinking_event(event, state:, yielder:)
-    state[:reasoning] ||= +""
-    state[:reasoning] << event.thinking
-    yielder << Riffer::StreamEvents::ReasoningDelta.new(event.thinking)
-  end
-
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_input_json_event(event, state:, yielder:)
@@ -320,18 +328,13 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     state[:tool_call] = nil
   end
 
+  # The SDK's accumulated block already carries the full thinking text and the
+  # signature from its trailing signature_delta.
   #--
-  #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_content_block_stop_thinking(_event, state:, yielder:)
-    yield_reasoning_done(yielder, state[:reasoning])
-    state[:reasoning] = nil
-  end
-
-  #--
-  #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_content_block_stop_text(_event, state:, yielder:)
-    yielder << Riffer::StreamEvents::TextDone.new(state[:text])
-    state[:text] = nil
+  #: (untyped, yielder: Riffer::Providers::_EventSink) -> void
+  def handle_content_block_stop_reasoning(event, yielder:)
+    part = build_reasoning_part(event.content_block) #: Riffer::Messages::Assistant::ReasoningPart
+    yielder << Riffer::StreamEvents::ReasoningDone.new(part)
   end
 
   #--
@@ -361,8 +364,10 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   end
 
   #--
-  #: (untyped, accumulated_message: untyped, yielder: Riffer::Providers::_EventSink) -> void
-  def handle_message_stop(_event, accumulated_message:, yielder:)
+  #: (untyped, state: Hash[Symbol, untyped], accumulated_message: untyped, yielder: Riffer::Providers::_EventSink) -> void
+  def handle_message_stop(_event, state:, accumulated_message:, yielder:)
+    yielder << Riffer::StreamEvents::TextDone.new(state[:text]) if state[:text]
+
     message = accumulated_message #: Anthropic::Models::Message?
     yield_finish_reason(yielder, build_finish_reason(message&.stop_reason))
 
@@ -413,7 +418,9 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   #--
   #: (Riffer::Messages::Assistant) -> Hash[Symbol, untyped]
   def convert_assistant_to_anthropic_format(message)
-    content = [] #: Array[Hash[Symbol, untyped]]
+    content = message.reasoning.filter_map do |part|
+      convert_reasoning_part_to_anthropic_format(part) if part.format == REASONING_FORMAT
+    end
     content << { type: "text", text: message.content } if message.content && !message.content.empty?
 
     message.tool_calls.each do |tc|
@@ -428,6 +435,14 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     { role: "assistant", content: content }
   end
 
+  #--
+  #: (Riffer::Messages::Assistant::ReasoningPart) -> Hash[Symbol, untyped]
+  def convert_reasoning_part_to_anthropic_format(part)
+    return { type: "redacted_thinking", data: part.data } if part.type == :encrypted
+
+    { type: "thinking", thinking: part.text, signature: part.signature }
+  end
+
   #--
   #: (Riffer::Messages::User::FilePart) -> Hash[Symbol, untyped]
   def convert_file_part_to_anthropic_format(file)

data/lib/riffer/providers/azure_open_ai.rb

@@ -26,4 +26,11 @@ class Riffer::Providers::AzureOpenAI < Riffer::Providers::OpenAI
     # OpenAI credential elsewhere. A nil raises in the SDK instead.
     ::OpenAI::Client.new(api_key: api_key, base_url: base_url)
   end
+
+  # Azure resolves and decrypts reasoning items only within the resource that produced them.
+  #--
+  #: () -> String
+  def reasoning_format
+    "azure-openai-v1"
+  end
 end

data/lib/riffer/providers/open_ai.rb

@@ -173,16 +173,12 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   #: (untyped) -> String
   def extract_content(response)
     typed_response = response #: OpenAI::Models::Responses::Response
-    text_content = ""
 
-    typed_response.output.each do |item|
-      next unless item.is_a?(::OpenAI::Models::Responses::ResponseOutputMessage)
-
-      text_block = item.content.find { |c| c.is_a?(::OpenAI::Models::Responses::ResponseOutputText) }
-      text_content = text_block.text if text_block.is_a?(::OpenAI::Models::Responses::ResponseOutputText)
-    end
+    typed_response.output.flat_map do |item|
+      next [] unless item.is_a?(::OpenAI::Models::Responses::ResponseOutputMessage)
 
-    text_content
+      item.content.filter_map { |c| c.text if c.is_a?(::OpenAI::Models::Responses::ResponseOutputText) }
+    end.join
   end
 
   #--
@@ -204,10 +200,47 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
     tool_calls
   end
 
+  #--
+  #: (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+  def extract_reasoning(response)
+    typed_response = response #: OpenAI::Models::Responses::Response
+    typed_response.output.
+      grep(::OpenAI::Models::Responses::ResponseReasoningItem).
+      flat_map { |item| build_reasoning_parts(item) }
+  end
+
+  # The trailing +:encrypted+ part is always present, even without a payload, so the item's id
+  # survives for replay: with +store+ on, OpenAI resolves the item from the id alone.
+  #--
+  #: (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+  def build_reasoning_parts(item)
+    typed_item = item #: OpenAI::Models::Responses::ResponseReasoningItem
+    id = typed_item.id
+    summaries = typed_item.summary.map { |summary| build_reasoning_part(type: :summary, id: id, text: summary.text) }
+    texts = (typed_item.content || []).map { |content| build_reasoning_part(type: :text, id: id, text: content.text) }
+
+    [*summaries, *texts, build_reasoning_part(type: :encrypted, id: id, data: typed_item.encrypted_content)]
+  end
+
+  #--
+  #: (type: Symbol, id: String, ?text: String?, ?data: String?) -> Riffer::Messages::Assistant::ReasoningPart
+  def build_reasoning_part(type:, id:, text: nil, data: nil)
+    Riffer::Messages::Assistant::ReasoningPart.new(type: type, text: text, data: data, id: id, format: reasoning_format)
+  end
+
+  # Distinct from OpenRouter's +openai-responses-v1+: reasoning relayed through OpenRouter is
+  # encrypted and stored under OpenRouter's organization, so neither side can replay the other's.
+  #--
+  #: () -> String
+  def reasoning_format
+    "openai-v1"
+  end
+
   #--
   #: (Hash[Symbol, untyped], Riffer::Providers::_EventSink) -> void
   def execute_stream(params, yielder)
     current_state = {
+      text: nil,
       tool_info: {},
     } #: Hash[Symbol, untyped]
 
@@ -223,12 +256,8 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
           end
         when :"response.output_text.delta"
           handle_output_text_delta(event, state: current_state, yielder: yielder)
-        when :"response.output_text.done"
-          handle_output_text_done(event, state: current_state, yielder: yielder)
         when :"response.reasoning_summary_text.delta"
           handle_reasoning_summary_text_delta(event, state: current_state, yielder: yielder)
-        when :"response.reasoning_summary_text.done"
-          handle_reasoning_summary_text_done(event, state: current_state, yielder: yielder)
         when :"response.function_call_arguments.delta"
           handle_function_call_arguments_delta(event, state: current_state, yielder: yielder)
         when :"response.function_call_arguments.done"
@@ -240,7 +269,10 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
         when :"response.web_search_call.completed"
           handle_web_search_status(event, status: "completed", yielder: yielder)
         when :"response.output_item.done"
-          handle_output_item_done_web_search(event, yielder: yielder) if event.item&.type == :web_search_call
+          case event.item&.type
+          when :web_search_call then handle_output_item_done_web_search(event, yielder: yielder)
+          when :reasoning then handle_output_item_done_reasoning(event, yielder: yielder)
+          end
         when :"response.completed", :"response.incomplete", :"response.failed"
           stream_completed = true
           handle_response_finished(event, state: current_state, yielder: yielder)
@@ -270,27 +302,19 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_output_text_delta(event, state:, yielder:)
+    # << avoids += copying the whole buffer per delta (O(n^2)); safe because
+    # nothing reads the buffer before the response finishes and TextDone takes it.
+    state[:text] ||= +""
+    state[:text] << event.delta
     yielder << Riffer::StreamEvents::TextDelta.new(event.delta)
   end
 
-  #--
-  #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_output_text_done(event, state:, yielder:)
-    yielder << Riffer::StreamEvents::TextDone.new(event.text)
-  end
-
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_reasoning_summary_text_delta(event, state:, yielder:)
     yielder << Riffer::StreamEvents::ReasoningDelta.new(event.delta)
   end
 
-  #--
-  #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_reasoning_summary_text_done(event, state:, yielder:)
-    yield_reasoning_done(yielder, event.text)
-  end
-
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_function_call_arguments_delta(event, state:, yielder:)
@@ -317,6 +341,8 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_response_finished(event, state:, yielder:)
+    yielder << Riffer::StreamEvents::TextDone.new(state[:text]) if state[:text]
+
     response = event.response
     return unless response
 
@@ -348,6 +374,12 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
     end
   end
 
+  #--
+  #: (untyped, yielder: Riffer::Providers::_EventSink) -> void
+  def handle_output_item_done_reasoning(event, yielder:)
+    build_reasoning_parts(event.item).each { |part| yielder << Riffer::StreamEvents::ReasoningDone.new(part) }
+  end
+
   #--
   #: (Array[Riffer::Messages::Base]) -> Array[Hash[Symbol, untyped]]
   def convert_messages_to_openai_format(messages)
@@ -378,12 +410,13 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   end
 
   #--
-  #: (Riffer::Messages::Assistant) -> (Hash[Symbol, untyped] | Array[Hash[Symbol, untyped]])
+  #: (Riffer::Messages::Assistant) -> Array[Hash[Symbol, untyped]]
   def convert_assistant_to_openai_format(message)
+    items = convert_reasoning_to_openai_format(message.reasoning)
+
     if message.tool_calls.empty?
-      { role: "assistant", content: message.content }
+      items << { role: "assistant", content: message.content }
     else
-      items = [] #: Array[Hash[Symbol, untyped]]
       if message.content && !message.content.empty?
         items << { type: "message", role: "assistant",
                    content: message.content, }
@@ -396,8 +429,33 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
           arguments: tc.arguments,
         }
       end
-      items
     end
+
+    items
+  end
+
+  #--
+  #: (Array[Riffer::Messages::Assistant::ReasoningPart]) -> Array[Hash[Symbol, untyped]]
+  def convert_reasoning_to_openai_format(reasoning)
+    reasoning.
+      select { |part| part.format == reasoning_format }.
+      chunk_while { |a, b| a.id == b.id }.
+      map { |parts| convert_reasoning_item_to_openai_format(parts) }
+  end
+
+  #--
+  #: (Array[Riffer::Messages::Assistant::ReasoningPart]) -> Hash[Symbol, untyped]
+  def convert_reasoning_item_to_openai_format(parts)
+    summary = parts.filter_map { |part| { type: "summary_text", text: part.text } if part.type == :summary }
+    content = parts.filter_map { |part| { type: "reasoning_text", text: part.text } if part.type == :text }
+
+    {
+      type: "reasoning",
+      id: parts.first&.id,
+      summary: summary,
+      content: content.empty? ? nil : content,
+      encrypted_content: parts.find { |part| part.type == :encrypted }&.data,
+    }.compact
   end
 
   #--

data/lib/riffer/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Riffer
-  VERSION = "0.49.0" #: String
+  VERSION = "0.50.0" #: String
 end

data/sig/generated/riffer/providers/amazon_bedrock.rbs

@@ -120,10 +120,6 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_reasoning_stop: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
 
-  # --
-  # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_content_block_stop_text_delta: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-
   # --
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_content_block_stop_tool_use: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void

data/sig/generated/riffer/providers/anthropic.rbs

@@ -5,6 +5,11 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
 
   FINISH_REASONS: Hash[String, Symbol]
 
+  # Only parts carrying this tag are replayed, so reasoning captured by another
+  # adapter, whose signatures the Messages API may not accept, never reaches the
+  # request.
+  REASONING_FORMAT: String
+
   # --
   # : (?String?) -> singleton(Riffer::Skills::Adapter)
   def self.skills_adapter: (?String?) -> singleton(Riffer::Skills::Adapter)
@@ -59,6 +64,14 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   # : (untyped) -> Array[Riffer::Messages::Assistant::ToolCall]
   def extract_tool_calls: (untyped) -> Array[Riffer::Messages::Assistant::ToolCall]
 
+  # --
+  # : (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+  def extract_reasoning: (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+
+  # --
+  # : (untyped) -> Riffer::Messages::Assistant::ReasoningPart?
+  def build_reasoning_part: (untyped) -> Riffer::Messages::Assistant::ReasoningPart?
+
   # --
   # : (Hash[Symbol, untyped], Riffer::Providers::_EventSink) -> void
   def execute_stream: (Hash[Symbol, untyped], Riffer::Providers::_EventSink) -> void
@@ -75,10 +88,6 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_text_event: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
 
-  # --
-  # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_thinking_event: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-
   # --
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_input_json_event: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
@@ -87,13 +96,11 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_content_block_stop_tool_use: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
 
+  # The SDK's accumulated block already carries the full thinking text and the
+  # signature from its trailing signature_delta.
   # --
-  # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_content_block_stop_thinking: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-
-  # --
-  # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_content_block_stop_text: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
+  # : (untyped, yielder: Riffer::Providers::_EventSink) -> void
+  def handle_content_block_stop_reasoning: (untyped, yielder: Riffer::Providers::_EventSink) -> void
 
   # --
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
@@ -104,8 +111,8 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   def handle_content_block_stop_web_search_result: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
 
   # --
-  # : (untyped, accumulated_message: untyped, yielder: Riffer::Providers::_EventSink) -> void
-  def handle_message_stop: (untyped, accumulated_message: untyped, yielder: Riffer::Providers::_EventSink) -> void
+  # : (untyped, state: Hash[Symbol, untyped], accumulated_message: untyped, yielder: Riffer::Providers::_EventSink) -> void
+  def handle_message_stop: (untyped, state: Hash[Symbol, untyped], accumulated_message: untyped, yielder: Riffer::Providers::_EventSink) -> void
 
   # --
   # : (Array[Riffer::Messages::Base]) -> Hash[Symbol, untyped]
@@ -115,6 +122,10 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   # : (Riffer::Messages::Assistant) -> Hash[Symbol, untyped]
   def convert_assistant_to_anthropic_format: (Riffer::Messages::Assistant) -> Hash[Symbol, untyped]
 
+  # --
+  # : (Riffer::Messages::Assistant::ReasoningPart) -> Hash[Symbol, untyped]
+  def convert_reasoning_part_to_anthropic_format: (Riffer::Messages::Assistant::ReasoningPart) -> Hash[Symbol, untyped]
+
   # --
   # : (Riffer::Messages::User::FilePart) -> Hash[Symbol, untyped]
   def convert_file_part_to_anthropic_format: (Riffer::Messages::User::FilePart) -> Hash[Symbol, untyped]

data/sig/generated/riffer/providers/azure_open_ai.rbs

@@ -14,4 +14,9 @@ class Riffer::Providers::AzureOpenAI < Riffer::Providers::OpenAI
   # --
   # : () -> untyped
   def build_client: () -> untyped
+
+  # Azure resolves and decrypts reasoning items only within the resource that produced them.
+  # --
+  # : () -> String
+  def reasoning_format: () -> String
 end

data/sig/generated/riffer/providers/open_ai.rbs

@@ -65,6 +65,26 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   # : (untyped) -> Array[Riffer::Messages::Assistant::ToolCall]
   def extract_tool_calls: (untyped) -> Array[Riffer::Messages::Assistant::ToolCall]
 
+  # --
+  # : (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+  def extract_reasoning: (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+
+  # The trailing +:encrypted+ part is always present, even without a payload, so the item's id
+  # survives for replay: with +store+ on, OpenAI resolves the item from the id alone.
+  # --
+  # : (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+  def build_reasoning_parts: (untyped) -> Array[Riffer::Messages::Assistant::ReasoningPart]
+
+  # --
+  # : (type: Symbol, id: String, ?text: String?, ?data: String?) -> Riffer::Messages::Assistant::ReasoningPart
+  def build_reasoning_part: (type: Symbol, id: String, ?text: String?, ?data: String?) -> Riffer::Messages::Assistant::ReasoningPart
+
+  # Distinct from OpenRouter's +openai-responses-v1+: reasoning relayed through OpenRouter is
+  # encrypted and stored under OpenRouter's organization, so neither side can replay the other's.
+  # --
+  # : () -> String
+  def reasoning_format: () -> String
+
   # --
   # : (Hash[Symbol, untyped], Riffer::Providers::_EventSink) -> void
   def execute_stream: (Hash[Symbol, untyped], Riffer::Providers::_EventSink) -> void
@@ -77,18 +97,10 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_output_text_delta: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
 
-  # --
-  # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_output_text_done: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-
   # --
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_reasoning_summary_text_delta: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
 
-  # --
-  # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-  def handle_reasoning_summary_text_done: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
-
   # --
   # : (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_function_call_arguments_delta: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
@@ -109,13 +121,25 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
   # : (untyped, yielder: Riffer::Providers::_EventSink) -> void
   def handle_output_item_done_web_search: (untyped, yielder: Riffer::Providers::_EventSink) -> void
 
+  # --
+  # : (untyped, yielder: Riffer::Providers::_EventSink) -> void
+  def handle_output_item_done_reasoning: (untyped, yielder: Riffer::Providers::_EventSink) -> void
+
   # --
   # : (Array[Riffer::Messages::Base]) -> Array[Hash[Symbol, untyped]]
   def convert_messages_to_openai_format: (Array[Riffer::Messages::Base]) -> Array[Hash[Symbol, untyped]]
 
   # --
-  # : (Riffer::Messages::Assistant) -> (Hash[Symbol, untyped] | Array[Hash[Symbol, untyped]])
-  def convert_assistant_to_openai_format: (Riffer::Messages::Assistant) -> (Hash[Symbol, untyped] | Array[Hash[Symbol, untyped]])
+  # : (Riffer::Messages::Assistant) -> Array[Hash[Symbol, untyped]]
+  def convert_assistant_to_openai_format: (Riffer::Messages::Assistant) -> Array[Hash[Symbol, untyped]]
+
+  # --
+  # : (Array[Riffer::Messages::Assistant::ReasoningPart]) -> Array[Hash[Symbol, untyped]]
+  def convert_reasoning_to_openai_format: (Array[Riffer::Messages::Assistant::ReasoningPart]) -> Array[Hash[Symbol, untyped]]
+
+  # --
+  # : (Array[Riffer::Messages::Assistant::ReasoningPart]) -> Hash[Symbol, untyped]
+  def convert_reasoning_item_to_openai_format: (Array[Riffer::Messages::Assistant::ReasoningPart]) -> Hash[Symbol, untyped]
 
   # --
   # : (Riffer::Messages::User::FilePart) -> Hash[Symbol, untyped]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer
 version: !ruby/object:Gem::Version
-  version: 0.49.0
+  version: 0.50.0
 platform: ruby
 authors:
 - Jake Bottrall