samagotchi 0.54.0 → 0.56.0

data/lib/samagotchi/kernel_loop.rb

@@ -32,6 +32,7 @@ require_relative "llm_context_notice"
 require_relative "answer_display"
 require_relative "llm/model_result"
 require_relative "llm/turn_settings"
+require_relative "llm/stream_drops"
 
 module Samagotchi
   # The KernelLoop drives the model ↔ tool interaction cycle.
@@ -47,6 +48,8 @@ module Samagotchi
   #   - Gemma 4: <|tool_call>call:NAME{params}<tool_call|>
   #   - Qwen 3.6: <tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>
   class KernelLoop
+    include LLM::StreamDrops
+
     # The built-in tool classes (Tools::Builtins registers them).
     TOOLS = Tools::Builtins::CLASSES
 
@@ -113,8 +116,12 @@ module Samagotchi
 
     # @param tools [Tools::Registry, nil] the tools calls dispatch to (the
     #   Engine's; nil: the built-ins alone)
-    def initialize(client: nil, profile: nil, model_name: nil, hooks: nil, reminder_store: nil, model_key: nil, tools: nil)
+    # @param sleeper [#call, nil] waits the given seconds before a dropped
+    #   stream's step is asked again (specs pass one that doesn't sleep)
+    def initialize(client: nil, profile: nil, model_name: nil, hooks: nil, reminder_store: nil, model_key: nil, tools: nil,
+                   sleeper: nil)
       @client = client || Client.new
+      @sleeper = sleeper || ->(seconds) { sleep(seconds) }
       @tools = tools || Tools::Builtins.default
       resolved_model_name = ModelProfile.required_model_name(model_name)
       # The turn's settings (LLM::TurnSettings). Its model name is the
@@ -349,9 +356,9 @@ module Samagotchi
     # Ends with its :generation_completed (and, unless cut, the
     # after_generation hook).
     def generate(turn, request)
-      # Each generation splits its own stream: one that ended inside a
-      # thought or a tool call doesn't leave the next one "inside" it.
-      stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
+      # Each ask splits its own stream (run_generation rebuilds the
+      # splitter), so one that ended inside a thought or a tool call doesn't
+      # leave the next one "inside" it.
       emit(turn, type: :generation_started, iteration: turn.iteration, context_window_tokens: request.window.tokens,
                  context_window_source: request.window.source, profile: @profile.name, profile_source: @profile_source,
                  price: @turn_settings.price&.to_h)
@@ -369,14 +376,55 @@ module Samagotchi
       uncached = turn.uncached_next
       turn.uncached_next = false
       generation.response = with_generation(turn.cancel_controller) do |generation_controller|
+        run_generation(turn, request, generation, generation_controller, buffer_mark, uncached)
+      rescue Client::RequestCancelled
+        raise unless cut?(generation_controller, turn.cancel_controller)
+
+        generation.cut = generation_controller.detail || {}
+        nil
+      end
+      generation.cut ? cut_generation(turn, generation, buffer_mark) : completed_generation(turn, request, generation)
+      generation
+    end
+
+    # One generation's request, asking again on a mid-stream drop (LLM::HTTP
+    # raises RetryExhausted once a stream that already showed something
+    # fails, where a retry would repeat output) up to MAX_STREAM_DROPS
+    # times after the transport's backoff: the partial reply is dropped and
+    # the step restarts from the same conversation, as generation_retrying
+    # with restarted: true. A cancel (before or during the wait) never
+    # retries; a refusal or a first-token timeout fails as before.
+    def run_generation(turn, request, generation, generation_controller, buffer_mark, uncached)
+      # The empty-retry sampling is taken once, before the ask-again loop:
+      # a drop's restart must still carry the nudge's 0.6 (as ChatLoop does
+      # per step), not lose it when request_sampling is asked again.
+      sampling = turn.empty_retry.request_sampling(@turn_settings.sampling)
+      count = LLM::StreamDrops::DropCount.new(0, 0)
+      begin
+        # Each ask splits its own stream: a drop mid tool call (or mid
+        # thinking) leaves the splitter inside that block, so rebuilding it
+        # keeps the restarted stream's prose in the right lane.
+        stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
+        # Each ask starts with streamed_any = false, but once any chunk of
+        # this ask is shown it stays shown: a held-back partial marker after
+        # real text must not clear it, or the drop below won't ask again.
+        streamed_any = false
         request_generation(
           request.prompt,
           generation_controller: generation_controller,
           cancel_controller: turn.cancel_controller,
           model_name: turn.model_name,
-          sampling: turn.empty_retry.request_sampling(@turn_settings.sampling),
+          sampling: sampling,
           cache_prompt: !uncached,
-          on_chunk: ->(chunk) { stream_chunk(turn, generation, stream_splitter, chunk) },
+          on_chunk: lambda { |chunk|
+            # Shown the way ChatLoop counts it: anything that split into
+            # text or thinking was shown (a tool-call delta counts too, even
+            # though its bytes are dropped from both lanes). stream_chunk runs
+            # for every chunk (it splits the stream and emits the chunk event);
+            # streamed_any is sticky — once shown it stays shown, so a
+            # held-back partial marker after real text doesn't clear it.
+            streamed_any = true if stream_chunk(turn, generation, stream_splitter, chunk)
+          },
           on_retry: lambda { |retry_event|
             # The retry streams from the start: its counts replace these.
             generation.usage = nil
@@ -388,17 +436,54 @@ module Samagotchi
           },
           images: request.images
         )
-      rescue Client::RequestCancelled
-        raise unless cut?(generation_controller, turn.cancel_controller)
+      rescue LLM::RetryExhausted => e
+        # A cancel that landed as the stream drops ends the turn canceled,
+        # not failed, whatever the drop's count.
+        cancelled = [turn.cancel_controller, generation_controller].compact.find(&:cancelled?)
+        raise Client::RequestCancelled, cancelled.reason if cancelled
+
+        count.requests += e.attempts.to_i
+        limit = stream_drop_limit(LLM::StreamDrops::MAX_STREAM_DROPS)
+        if count.drops >= limit || !streamed_any
+          raise if count.requests == e.attempts.to_i
+
+          raise LLM::RetryExhausted.new(attempts: count.requests, last_error: e.last_error, label: e.host)
+        end
 
-        generation.cut = generation_controller.detail || {}
-        nil
+        count.drops += 1
+        attempt = count.drops
+        # restarted: the step's streamed chunks so far are void (the UIs and
+        # the Bridge's TurnAccumulator drop them); the same prompt goes
+        # again from where the step started, and the failed attempt's
+        # counts (mirroring the transport-retry reset) don't linger onto it.
+        turn.buffer.slice!(buffer_mark..)
+        turn.streamed_thinking = +""
+        generation.usage = nil
+        generation.cache = nil
+        generation.served_model = nil
+        generation.finish_reason = nil
+        generation.streamed_thinking = 0
+        delay = generation_retry_delay(attempt)
+        emit(turn, type: :generation_retrying, iteration: turn.iteration, attempt: attempt, max_retries: limit,
+                   next_delay: delay, error_class: e.class.name, error_message: e.message, status: nil, restarted: true)
+        wait_retry(delay, turn.cancel_controller, generation_controller)
+        retry
+      rescue LLM::ProviderError => e
+        # Another failure (a 503, a refusal) after earlier requests this
+        # step: its count takes theirs in.
+        count.requests += e.attempts.to_i
+        e.attempts = count.requests
+        raise
       end
-      generation.cut ? cut_generation(turn, generation, buffer_mark) : completed_generation(turn, request, generation)
-      generation
     end
 
+    # Whether the chunk showed anything: a delta that split into text or
+    # thinking was shown, and a tool-call delta too (its bytes are dropped
+    # from both lanes, but it still counts). run_generation reads this to
+    # decide whether a dropped stream actually streamed its partial reply.
     def stream_chunk(turn, generation, stream_splitter, chunk)
+      split = stream_splitter.feed(chunk[:content])
+      shown = !split[:text].to_s.empty? || !split[:thinking].to_s.empty? || split[:tool]
       generation.usage = turn.context.capture(chunk[:payload]) || generation.usage
       note_cache_counts(generation, chunk[:payload])
       # llama.cpp names the loaded model in the stream's last payload.
@@ -407,18 +492,16 @@ module Samagotchi
       slot = chunk[:payload]["id_slot"] if chunk[:payload].is_a?(Hash)
       @last_slot = slot if slot.is_a?(Integer)
       generation.finish_reason = chunk[:finish_reason] if chunk[:finish_reason]
-      split = stream_splitter.feed(chunk[:content])
       turn.buffer << split[:text]
       turn.streamed_thinking << split[:thinking].to_s
       generation.streamed_thinking += split[:thinking].to_s.length
-      return unless turn.on_stream_event
-
       event = { type: :generation_chunk, iteration: turn.iteration, content: chunk[:content], text: split[:text],
                 thinking: split[:thinking], payload: event_payload(chunk[:payload]) }
       # A chunk of a tool call (its bytes are dropped from both lanes): a
       # steer doesn't cut this generation (Engine#cut_for_steer).
       event[:tool_call] = true if split[:tool]
-      emit(turn, **event)
+      emit(turn, **event) if turn.on_stream_event
+      shown
     end
 
     # The payload a :generation_chunk event carries: llama.cpp's last chunk

data/lib/samagotchi/llm/chat_loop.rb

@@ -8,6 +8,7 @@ require_relative "errors"
 require_relative "usage"
 require_relative "openai_chat"
 require_relative "native_tool_normalizer"
+require_relative "stream_drops"
 require_relative "../kernel_loop"
 require_relative "../answer_display"
 require_relative "../cut_policy"
@@ -44,6 +45,8 @@ module Samagotchi
     # Cancel closes the request's socket (LLM::HTTP), so it works on any
     # thread; the text streamed so far is kept, marked [interrupted].
     class ChatLoop < ModelBackend
+      include LLM::StreamDrops
+
       attr_accessor :adapter
       # The session every request is for; Engine sets it with the adapter.
       # Goes out as a Session-Id header (OpenAIChat#chat).
@@ -63,42 +66,6 @@ module Samagotchi
         @sleeper = sleeper || ->(seconds) { sleep(seconds) }
       end
 
-      # How many times a dropped stream's step may be asked again: +cap+, or
-      # retry.max when that is smaller (retry.max: 0 turns it off, as it
-      # does the transport's retries).
-      def stream_drop_limit(cap)
-        [cap, HTTP::RetryPolicy.from_config.max].min
-      rescue StandardError
-        cap
-      end
-
-      # The seconds before the +attempt+-th ask-again of a dropped stream's
-      # step: the transport's own backoff (retry.base_delay doubling, capped
-      # at retry.max_delay; LLM::HTTP::RetryPolicy), 0 when retry.max is
-      # spent.
-      def generation_retry_delay(attempt)
-        HTTP::RetryPolicy.from_config.delay_for(attempt) || 0.0
-      rescue StandardError
-        0.0
-      end
-
-      # Waits +seconds+ in short slices, raising RequestCancelled as soon as
-      # one of +controllers+ (the turn's, the generation's) is cancelled, as
-      # LLM::HTTP's own wait between retries does.
-      def wait_retry(seconds, *controllers)
-        remaining = seconds.to_f
-        while remaining.positive?
-          cancelled = controllers.compact.find(&:cancelled?)
-          raise RequestCancelled, cancelled.reason if cancelled
-
-          slice = [remaining, 0.05].min
-          @sleeper.call(slice)
-          remaining -= slice
-        end
-        cancelled = controllers.compact.find(&:cancelled?)
-        raise RequestCancelled, cancelled.reason if cancelled
-      end
-
       def provider = :chat
 
       def complete(messages:, max_iterations: IterationLimit::DEFAULT, on_stream_event: nil, cancel_controller: nil,
@@ -164,11 +131,17 @@ module Samagotchi
       # as one user message "[images from tool results]". Images the request
       # leaves out (ImagePlan) become placeholder lines in the text.
       #
+      # A model turn carries its saved reasoning as reasoning_content when
+      # +reasoning+ (a ReasoningHistory level; the turn's by default) says
+      # so: under turn the running turn's only (#reasoning_boundary, with
+      # +since+ the Run's start), under all every one.
+      #
       # The conversation goes through the kernel's LLMContextView first,
-      # as the native prompt does.
-      def wire_messages(conversation)
+      # as the native prompt does (it keeps every entry in place).
+      def wire_messages(conversation, since: nil, reasoning: reasoning_history)
         conversation = llm_context_view.messages(conversation)
         paired = paired_call_ids(conversation)
+        boundary = reasoning_boundary(conversation, since: since, level: reasoning)
         plan = ImagePlan.new(conversation, vision)
         tool_images = []
         wire = []
@@ -182,7 +155,9 @@ module Samagotchi
             content = Steer.header(entry) ? Steer.wire_text(entry, entry[:content].to_s) : entry[:content]
             wire << { role: "user", content: parts(content, items) }
           when "model"
-            wire << assistant_message(entry, paired)
+            message = assistant_message(entry, paired)
+            message[:reasoning_content] = entry[:thinking] if boundary && index >= boundary && thought?(entry)
+            wire << message
           when "tool_response"
             id = entry[:tool_call_id]
             if id && paired.include?(id)
@@ -215,6 +190,44 @@ module Samagotchi
 
       TOOL_IMAGES_TEXT = "[images from tool results]"
 
+      # The first index whose model entries carry their reasoning (nil:
+      # none do) under +level+. Under turn: past both the last query (a
+      # user message: a prompt, a steer, merged input, the chat template's
+      # last query; or an entry that starts a turn, turn_start) and +since+
+      # (the Run's start, so a continue turn -- a reminder, a context wake,
+      # a continue after a stop -- sends none of the run before it).
+      # @return [Integer, nil]
+      def reasoning_boundary(conversation, since: nil, level: reasoning_history)
+        case level
+        when :all then 0
+        when :turn
+          query = conversation.rindex { |entry| entry[:role].to_s == "user" || entry[:turn_start] == true }
+          [query ? query + 1 : 0, since.to_i].max
+        end
+      end
+
+      # The reasoning +conversation+'s wire messages carry from +since+ on
+      # (#reasoning_boundary), in characters.
+      def reasoning_chars(conversation, since: nil, reasoning: reasoning_history)
+        boundary = reasoning_boundary(conversation, since: since, level: reasoning) or return 0
+        conversation.drop(boundary).sum { |entry| entry[:role].to_s == "model" && thought?(entry) ? entry[:thinking].length : 0 }
+      end
+
+      # The turn's ReasoningHistory level (the kernel's turn_settings); drop
+      # without settings, and for a +model+ whose host refused it
+      # (#reasoning_history_refused!).
+      def reasoning_history(model = nil)
+        return :drop if model && @reasoning_history_refused&.include?(model)
+
+        @kernel.turn_settings&.reasoning_history || :drop
+      end
+
+      # The host refused +model+'s reasoning sent back: send none from now on
+      # (this worker's lifetime, as #thinking_refused!).
+      def reasoning_history_refused!(model)
+        (@reasoning_history_refused ||= Set.new) << model
+      end
+
       # The turn's VisionContext (the Engine sets the kernel's
       # turn_settings), or nil.
       def vision = @kernel.turn_settings.vision
@@ -282,7 +295,7 @@ module Samagotchi
 
       # The shape the engine persists: role and content (parts stay an
       # Array), plus a model turn's tool_calls and thinking (the host's
-      # reasoning, never sent back), a result's tool_call_id, the image
+      # reasoning, sent back as #wire_messages says), a result's tool_call_id, the image
       # refs of a user message or a tool result, a prompt's turn_id (Engine,
       # never sent) and a wake turn's report's turn_start (Steer, never sent), and a plugin tool result's tool_params and tool_labels
       # (the live row's params line and label, never sent back), an
@@ -380,6 +393,8 @@ module Samagotchi
         notes.empty? ? text : [text, *notes].reject(&:empty?).join("\n")
       end
 
+      def thought?(entry) = entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?
+
       def scrub(text)
         text.encoding == Encoding::UTF_8 && !text.valid_encoding? ? text.scrub("?") : text
       end
@@ -394,6 +409,9 @@ module Samagotchi
           @cancel_controller = cancel_controller
           @model_name = model_name
           @pending_input = pending_input
+          # Where this run's entries start: the reasoning it sends back
+          # (ChatLoop#reasoning_boundary) is its own.
+          @start = conversation.length
           @tool_activity = []
           @empty_retry = EmptyAnswerRetry.new
           # The empty generations, never saved: the UIs draw the turn's
@@ -486,8 +504,8 @@ module Samagotchi
 
         # The host's reasoning, kept on the model message as +thinking+ for
         # the web turn view's reload (the whole of it, as the live view
-        # shows). Only saved: #assistant_message builds the wire message from
-        # content and tool_calls, so it never goes back to the model.
+        # shows), and sent back to the model as ChatLoop#wire_messages says
+        # (reasoning_history).
         def with_thinking(message, response)
           reasoning = response.reasoning.to_s
           reasoning.strip.empty? ? message : message.merge(thinking: reasoning)
@@ -510,18 +528,17 @@ module Samagotchi
           generation_controller = nil
           response = with_generation do |controller|
             generation_controller = controller
-            # One count for the step: the ask-again without thinking fields
-            # doesn't get drops of its own.
-            drops = DropCount.new(0, 0)
+            # One count for the step: an ask-again without reasoning or
+            # thinking fields doesn't get drops of its own.
+            drops = LLM::StreamDrops::DropCount.new(0, 0)
+            ask = -> { request_with_drops(iteration, retry_generation, streamed, thought, drops, controller) }
             begin
-              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
+              ask.call
             rescue BadRequest => e
-              raise unless thinking_refused?(e)
-
-              # Once per model: asked again without the thinking fields.
-              @loop.thinking_refused!(@model_name)
-              emit(type: :thinking_refused, iteration: iteration, model: @model_name, level: @loop.thinking, detail: e.detail)
-              request_with_drops(iteration, retry_generation, streamed, thought, drops, controller)
+              if refused?(e) && reasoning_sent? then without_reasoning(iteration, e, ask)
+              elsif thinking_refused?(e) then without_thinking(iteration, e, ask)
+              else raise
+              end
             end
           rescue RequestCancelled
             raise unless generation_controller&.cancelled? && !@cancel_controller.cancelled?
@@ -571,7 +588,7 @@ module Samagotchi
 
         def request(iteration, retry_generation, streamed, thought, generation_controller, streamed_any = nil)
           @loop.adapter.chat(
-            messages: @loop.wire_messages(@conversation), tools: @loop.tool_definitions, model: @model_name,
+            messages: @loop.wire_messages(@conversation, since: @start, reasoning: reasoning_level), tools: @loop.tool_definitions, model: @model_name,
             cancel_controller: generation_controller || @cancel_controller, session_id: @loop.session_id,
             options: @loop.request_options(retry_generation: retry_generation, model: @model_name),
             on_delta: lambda { |content:, reasoning:, payload:|
@@ -596,16 +613,8 @@ module Samagotchi
         # none with 0), after the transport's backoff: the partial reply is
         # dropped and the step restarts. A refusal or a first-token timeout
         # fails as before, and a cancel (before or during the wait) never
-        # retries.
-        MAX_STREAM_DROPS = 2
-
-        # A step's drops asked again (+drops+) and the HTTP requests made so
-        # far (+requests+: each failed request's transport attempts), so the
-        # error that ends the step counts every request, not the last one's.
-        DropCount = Struct.new(:drops, :requests)
-
-        # Runs one request, asking again on a mid-stream drop; +count+ (a
-        # DropCount) carries on across calls for one step.
+        # retries. +count+ (a DropCount) carries on across calls for one
+        # step.
         def request_with_drops(iteration, retry_generation, streamed, thought, count, generation_controller)
           streamed_any = false
           request(iteration, retry_generation, streamed, thought, generation_controller, -> { streamed_any = true })
@@ -616,7 +625,7 @@ module Samagotchi
           raise RequestCancelled, cancelled.reason if cancelled
 
           count.requests += e.attempts.to_i
-          limit = @loop.stream_drop_limit(MAX_STREAM_DROPS)
+          limit = @loop.stream_drop_limit(LLM::StreamDrops::MAX_STREAM_DROPS)
           if count.drops >= limit || !streamed_any
             raise if count.requests == e.attempts.to_i
 
@@ -642,11 +651,52 @@ module Samagotchi
           raise
         end
 
-        # A 400 about reasoning, for a request that carried thinking fields
-        # (not a missing-tools, image or context error).
-        def thinking_refused?(error)
+        # A 400 about reasoning (not a missing-tools, image or context error).
+        def refused?(error)
           error.reasoning_refused? && !error.is_a?(VisionUnsupported) && !error.tools_unsupported? &&
-            !error.context_overflow? && !@loop.thinking_fields(@model_name).empty?
+            !error.context_overflow?
+        end
+
+        # #refused?, for a request that carried thinking fields.
+        def thinking_refused?(error) = refused?(error) && !@loop.thinking_fields(@model_name).empty?
+
+        # Whether this step's request sends reasoning back.
+        def reasoning_sent?
+          !@without_reasoning && @loop.reasoning_chars(@conversation, since: @start, reasoning: reasoning_level).positive?
+        end
+
+        # The level this step's request sends reasoning back under: none
+        # while it is asked again without (#without_reasoning).
+        def reasoning_level = @without_reasoning ? :drop : @loop.reasoning_history(@model_name)
+
+        # The host refused a request that sent reasoning back: ask the step
+        # again without it. When that goes through, the model sends none from
+        # now on. When it is refused too, the thinking fields may be what the
+        # host refuses: #without_thinking asks a third time (still without
+        # reasoning; a later step sends it again, so a host that refuses
+        # only the thinking fields keeps it).
+        def without_reasoning(iteration, error, ask)
+          @without_reasoning = true
+          response = begin
+            ask.call
+          rescue BadRequest => e
+            raise unless thinking_refused?(e)
+
+            return without_thinking(iteration, e, ask)
+          end
+          @loop.reasoning_history_refused!(@model_name)
+          emit(type: :reasoning_history_refused, iteration: iteration, model: @model_name,
+               level: @loop.reasoning_history, detail: error.detail)
+          response
+        ensure
+          @without_reasoning = false
+        end
+
+        # Once per model: asked again without the thinking fields.
+        def without_thinking(iteration, error, ask)
+          @loop.thinking_refused!(@model_name)
+          emit(type: :thinking_refused, iteration: iteration, model: @model_name, level: @loop.thinking, detail: error.detail)
+          ask.call
         end
 
         # Before a request, as the native loop: estimate how full the window
@@ -671,10 +721,11 @@ module Samagotchi
 
         # The conversation's text as the request carries it, through the
         # kernel's LLMContextView (a stub counts, not the output it stands
-        # for): contents (a parts list's text parts) and the tool calls'
-        # names and arguments.
+        # for): contents (a parts list's text parts), the tool calls'
+        # names and arguments, and the reasoning sent back.
         def prompt_chars
-          LLMContextView.chars(@loop.llm_context_view.messages(@conversation))
+          LLMContextView.chars(@loop.llm_context_view.messages(@conversation)) +
+            @loop.reasoning_chars(@conversation, since: @start, reasoning: reasoning_level)
         end
 
         # The server's counts for this request (prompt + answer): the status

data/lib/samagotchi/llm/openai_chat.rb

@@ -333,10 +333,11 @@ module Samagotchi
       end
 
       # A String stays a String, an Array of parts an Array; both scrubbed
-      # of invalid UTF-8 (Utf8Scrub).
+      # of invalid UTF-8 (Utf8Scrub), as is reasoning sent back.
       def wire_message(message)
         wire = message.to_h.transform_keys(&:to_sym)
         wire[:content] = format_content(wire[:content]) if wire.key?(:content)
+        wire[:reasoning_content] = format_content(wire[:reasoning_content]) if wire.key?(:reasoning_content)
         wire
       end
 

data/lib/samagotchi/llm/stream_drops.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "http"
+
+module Samagotchi
+  module LLM
+    # A stream that dropped mid-answer is asked again from the same
+    # conversation: the same limit, backoff and cancel behaviour for both
+    # the chat loop and the native loop, so a native /completion and a chat
+    # request react identically to a dropped stream.
+    #
+    # The helpers the ask-again loop needs: how many times a dropped
+    # stream's step may be asked (stream_drop_limit), the transport's own
+    # backoff before the ask-again (generation_retry_delay), and the
+    # cancel-checking wait between the asks (wait_retry).
+    module StreamDrops
+      # The most times one step's dropped stream is asked again (both loops;
+      # stream_drop_limit lowers it under a smaller retry.max).
+      MAX_STREAM_DROPS = 2
+
+      # A step's drops asked again (+drops+) and the HTTP requests made so
+      # far (+requests+: each failed request's transport attempts), so the
+      # error that ends the step counts every request, not the last one's.
+      DropCount = Struct.new(:drops, :requests)
+
+      # How many times a dropped stream's step may be asked again: +cap+,
+      # or retry.max when that is smaller (retry.max: 0 turns it off, as it
+      # does the transport's retries).
+      def stream_drop_limit(cap)
+        [cap, HTTP::RetryPolicy.from_config.max].min
+      rescue StandardError
+        cap
+      end
+
+      # The seconds before the +attempt+-th ask-again of a dropped stream's
+      # step: the transport's own backoff (LLM::HTTP::RetryPolicy), 0 when
+      # retry.max is spent.
+      def generation_retry_delay(attempt)
+        HTTP::RetryPolicy.from_config.delay_for(attempt) || 0.0
+      rescue StandardError
+        0.0
+      end
+
+      # Waits +seconds+ in short slices, raising RequestCancelled as soon as
+      # one of +controllers+ (the turn's, the generation's) is cancelled,
+      # as LLM::HTTP's own wait between retries does.
+      def wait_retry(seconds, *controllers)
+        remaining = seconds.to_f
+        while remaining.positive?
+          cancelled = controllers.compact.find(&:cancelled?)
+          raise RequestCancelled, cancelled.reason if cancelled
+
+          slice = [remaining, 0.05].min
+          @sleeper.call(slice)
+          remaining -= slice
+        end
+        cancelled = controllers.compact.find(&:cancelled?)
+        raise RequestCancelled, cancelled.reason if cancelled
+      end
+    end
+  end
+end

data/lib/samagotchi/llm/turn_settings.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../thinking"
+require_relative "../reasoning_history"
 
 module Samagotchi
   module LLM
@@ -8,17 +9,20 @@ module Samagotchi
     # ChatLoop) and ToolRunner: the turn's VisionContext (nil sends no
     # images, placeholders instead), its request parameters
     # (SamplingSettings.for; empty sends none), its thinking level
-    # (Thinking.resolve), the bare model id the turn runs on (every debug
+    # (Thinking.resolve), which of its reasoning ChatLoop sends back
+    # (ReasoningHistory.resolve; ignored on the native loop), the bare model id the turn runs on (every debug
     # dump is tagged with it) and the model's or host's configured context
     # window (ContextWindow.setting, nil for none) and LLM context strategy
     # (LLMContextStrategy.resolve, nil for none), and its price on its host
     # (hosts.<name>.models.<id>.price, a ModelPrice; nil for none), what
     # SessionMetrics estimates an unreported cost from. The Engine sets them once
     # per turn, in Engine#generate, after the model's host is synced.
-    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name, :window_setting, :llm_context, :price) do
-      # No vision, no sampling, the default thinking, no model name.
-      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil,
-                          window_setting: nil, llm_context: nil, price: nil)
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :reasoning_history, :model_name, :window_setting,
+                               :llm_context, :price) do
+      # No vision, no sampling, the default thinking, no reasoning sent
+      # back, no model name.
+      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, reasoning_history: :drop,
+                          model_name: nil, window_setting: nil, llm_context: nil, price: nil)
     end
   end
 end

data/lib/samagotchi/model_settings.rb

@@ -2,16 +2,18 @@
 
 require_relative "config"
 require_relative "llm_context_strategy"
+require_relative "reasoning_history"
 
 module Samagotchi
   # One config.yml models: entry (per-model settings keyed by model id or
   # alias), parsed and checked; ConfigFile.model_settings holds them by
   # downcased key. Each field is nil when unset: profile kept as written
   # (downcased; ModelProfile.resolve validates it), vision true/false,
-  # sampling a request-field map, thinking a level, window_tokens, and the
+  # sampling a request-field map, thinking a level, reasoning_history a
+  # ReasoningHistory level, window_tokens, and the
   # LLM context strategy, apply rule and budget (LLMContextStrategy). The
   # same per-model fields a hosts: entry carries (HostConfig).
-  ModelSettings = Data.define(:profile, :vision, :sampling, :thinking, :window_tokens,
+  ModelSettings = Data.define(:profile, :vision, :sampling, :thinking, :reasoning_history, :window_tokens,
                               :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens) do
     # Every field may be left out (nil).
     def initialize(**fields)
@@ -33,6 +35,7 @@ module Samagotchi
           vision: ConfigFile.vision_flag(value.call(:vision), where),
           sampling: ConfigFile.sampling_map(value.call(:sampling), where),
           thinking: Thinking.level(value.call(:thinking), where),
+          reasoning_history: ReasoningHistory.level(value.call(:reasoning_history), where),
           window_tokens: ConfigFile.window_tokens(value.call(:window_tokens), where),
           llm_context_strategy: LLMContextStrategy.parse(value.call(LLMContextStrategy::KEY), where),
           llm_context_apply: LLMContextStrategy.parse_apply(value.call(LLMContextStrategy::APPLY_KEY), where),