samagotchi 0.55.0 → 0.56.0

data/lib/samagotchi/engine.rb

@@ -62,6 +62,7 @@ require_relative "vision_context"
 require_relative "vision_support"
 require_relative "sampling_settings"
 require_relative "thinking"
+require_relative "reasoning_history"
 require_relative "answer_display"
 require_relative "edit_preview"
 require_relative "question_desk"
@@ -1010,7 +1011,8 @@ module Samagotchi
       served, served_for = served_model_for(snapshot, target: target)
       snapshot = snapshot.merge(served_model: served, served_model_for: served_for,
                                 served_expected_by: served_expected_by(served, target: target), llm_context: llm_context_summary,
-                                thinking: thinking_explained&.summary, prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
+                                thinking: thinking_explained&.summary,
+                                reasoning_history: reasoning_history_explained&.summary, prompt_notes: prompt_notes.map(&:to_h), price_host: target.entry.name)
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
         if window
@@ -1093,16 +1095,80 @@ module Samagotchi
     end
 
     # The effective model's thinking level with where it came from and the
-    # session's own (Thinking::Explained), as the next turn resolves it;
+    # session's own (SettingExplained), as the next turn resolves it;
     # nil when it can't be resolved.
-    # @return [Thinking::Explained, nil]
-    def thinking_explained
+    # @return [SettingExplained, nil]
+    # +own+: the session's own level to resolve with (the current one by
+    # default; /thinking asks what a change would resolve to).
+    def thinking_explained(own: thinking_override)
       target = @host_registry.resolve(@effective_model_name)
-      Thinking.explain(target, names: model_lookup_names(target), session: thinking_override)
+      Thinking.explain(target, names: model_lookup_names(target), session: own)
     rescue StandardError
       nil
     end
 
+    # "drop (models: qwen)" for /model: the effective chat model's
+    # reasoning_history level and where it came from; nil when it is the
+    # default, the model runs on the native loop (which ignores it) or it
+    # can't be resolved.
+    def reasoning_history_summary
+      target = @host_registry.resolve(@effective_model_name)
+      return nil unless target.entry&.chat?
+
+      level, source = ReasoningHistory.resolve(target, names: model_lookup_names(target),
+                                                       session: reasoning_history_override)
+      source ? ReasoningHistory.label(level, source) : nil
+    rescue StandardError
+      nil
+    end
+
+    # The effective chat model's reasoning_history level with where it came
+    # from and the session's own (SettingExplained), as the next turn
+    # resolves it; nil on a native host (the native loop ignores it; native:
+    # true resolves it there too, for /reasoning-history) or when it can't
+    # be resolved.
+    # @return [SettingExplained, nil]
+    # +own+: the session's own level to resolve with (the current one by
+    # default; a command asks what a change would resolve to).
+    def reasoning_history_explained(native: false, own: reasoning_history_override)
+      target = @host_registry.resolve(@effective_model_name)
+      return nil unless native || target.entry&.chat?
+
+      ReasoningHistory.explain(target, names: model_lookup_names(target), session: own)
+    rescue StandardError
+      nil
+    end
+
+    # What a reasoning_history change from level +from+ to level +to+ costs
+    # the effective model's prompt cache, given the session's conversation
+    # (ReasoningHistory.cache_cost): :history or nil. A host ChatLoop
+    # marked as refusing it may still get :history (one needless ask).
+    # @return [Symbol, nil]
+    def reasoning_history_cache_cost(from, to)
+      target = @host_registry.resolve(@effective_model_name)
+      ReasoningHistory.cache_cost(from, to, target: target, conversation: @session&.messages)
+    rescue StandardError
+      nil
+    end
+
+    # Whether the session has a model reply (a cache to restart at all).
+    def history?
+      Array(@session&.messages).any? { |entry| entry[:role].to_s == "model" }
+    end
+
+    # The session's own reasoning_history level, nil when it has none.
+    # @return [Symbol, nil]
+    def reasoning_history_override = @session&.reasoning_history
+
+    # Set the session's own reasoning_history level (nil unsets it); the
+    # next turn's start resolves it. The caller saves the session.
+    # @raise [ArgumentError] with no session yet
+    def reasoning_history_override=(level)
+      raise ArgumentError, "no session yet" unless @session
+
+      @session.reasoning_history = level
+    end
+
     # The session's own thinking level, nil when it has none.
     # @return [Symbol, nil]
     def thinking_override = @session&.thinking
@@ -1192,6 +1258,7 @@ module Samagotchi
         context_status: @last_context_status&.dup || saved_context_status(metrics[:context]),
         llm_context: llm_context_summary,
         thinking: thinking_explained&.summary,
+        reasoning_history: reasoning_history_explained&.summary,
         recap_enabled: !@recap.nil?,
         recap_min_user_turns: @recap&.min_user_turns,
         recap_inactivity_seconds: @recap&.inactivity&.to_i
@@ -1926,7 +1993,8 @@ module Samagotchi
       thinking_target = @host_registry.resolve(@effective_model_name)
       @turn_thinking = [thinking_level(thinking_target), thinking_target]
       announce_thinking_level(*@turn_thinking)
-      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil,
+      LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first,
+                            reasoning_history: reasoning_history_level(thinking_target), model_name: nil,
                             window_setting: nil, llm_context: nil, price: nil)
     end
     private :turn_settings
@@ -2317,6 +2385,23 @@ module Samagotchi
       nil
     end
 
+    # The host refused the model's reasoning sent back (reasoning_history)
+    # and the chat loop asked the step again without it, as it will from
+    # now on: logged, and said once per session and host.
+    def reasoning_history_refused(event)
+      _level, target = @turn_thinking
+      return unless target
+
+      Log.warn(:model, "reasoning_history_refused", level: event[:level], host: target.entry.name, model: event[:model],
+                                                    detail: event[:detail])
+      return unless (@thinking_notices ||= Set.new).add?([@session&.id, target.entry.name, :reasoning_history_refused])
+
+      hook_notify("#{target.entry.name} refused reasoning sent back (reasoning_history: #{event[:level]}) for " \
+                  "#{event[:model]} (#{event[:detail]}); sent without it from now on", :warn, "reasoning history")
+    rescue StandardError
+      nil
+    end
+
     def thinking_notice_once(kind, target, level, text)
       key = [@session&.id, target.entry.name, kind]
       return unless (@thinking_notices ||= Set.new).add?(key)
@@ -2324,6 +2409,14 @@ module Samagotchi
       hook_notify(text, level, "thinking")
     end
 
+    # +target+'s ReasoningHistory level, the session's own first; the
+    # default when it can't be resolved.
+    def reasoning_history_level(target)
+      ReasoningHistory.resolve(target, names: model_lookup_names(target), session: reasoning_history_override).first
+    rescue StandardError
+      ReasoningHistory::DEFAULT
+    end
+
     # +target+'s thinking level (Thinking.resolve), the session's own first.
     def thinking_level(target)
       Thinking.resolve(target, names: model_lookup_names(target), session: thinking_override).first
@@ -2602,9 +2695,10 @@ module Samagotchi
           end
         when :generation_chunk then note_generation_thought(progress[:thinking])
         end
-        # The chat loop asked again without the thinking fields: a notice,
-        # not an event of its own.
+        # The chat loop asked again without the thinking fields or the
+        # reasoning sent back: a notice, not an event of its own.
         next thinking_refused(event) if event[:type] == :thinking_refused
+        next reasoning_history_refused(event) if event[:type] == :reasoning_history_refused
 
         event = with_generation_report(event) if event[:type] == :generation_completed
         emit_event(on_event, event)

data/lib/samagotchi/engine_peers.rb

@@ -18,6 +18,7 @@ module Samagotchi
       def relay = engine.relay_peer
       def model_ref = engine.effective_model_ref
       def thinking = engine.thinking_override
+      def reasoning_history = engine.reasoning_history_override
     end
 
     # What the approval relay needs from the parent's Engine (Peers#relay):

data/lib/samagotchi/host_config.rb

@@ -4,6 +4,7 @@ require "uri"
 require_relative "config"
 require_relative "host_model"
 require_relative "llm_context_strategy"
+require_relative "reasoning_history"
 
 module Samagotchi
   # One config.yml hosts: entry, parsed and checked (ConfigFile.hosts_config
@@ -17,8 +18,9 @@ module Samagotchi
   # api: symbols, nil when unset; the rest as HostRegistry::HostEntry
   # describes them, nil when unset; models: {downcased id => HostModel}.
   HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, :models) do
+                           :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
+                           :window_tokens, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
+                           :models) do
     # Every field but name may be left out: nil, models {}.
     def initialize(**fields)
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
@@ -50,6 +52,7 @@ module Samagotchi
         window_tokens: ConfigFile.window_tokens(value.call(:window_tokens), 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),
         llm_context_strategy: LLMContextStrategy.parse(value.call(LLMContextStrategy::KEY), where),
         llm_context_apply: LLMContextStrategy.parse_apply(value.call(LLMContextStrategy::APPLY_KEY), where),
         models: HostModel.parse_map(value.call(:models), name),
@@ -166,7 +169,7 @@ module Samagotchi
       location.merge("transport" => transport&.to_s, "api" => api&.to_s, "api_key_env" => api_key_env,
                      "profile" => profile, "first_token_timeout" => first_token_timeout,
                      "vision" => vision, "sampling" => sampling, "thinking" => thinking&.to_s,
-                     "remote" => remote, "window_tokens" => window_tokens,
+                     "reasoning_history" => reasoning_history&.to_s, "remote" => remote, "window_tokens" => window_tokens,
                      "llm_context_strategy" => llm_context_strategy&.map(&:to_s),
                      "llm_context_apply" => llm_context_apply&.to_s,
                      "llm_context_budget_tokens" => llm_context_budget_tokens,

data/lib/samagotchi/host_registry.rb

@@ -35,6 +35,7 @@ module Samagotchi
     # vision: the configured true/false (VisionSupport), nil when unset;
     # sampling: the configured request parameters (SamplingSettings), nil when unset;
     # thinking: the configured level (Thinking), nil when unset;
+    # reasoning_history: the configured level (ReasoningHistory), nil when unset;
     # remote: the configured true/false (#remote?), nil when unset;
     # window_tokens: the configured context window (ContextWindow.setting), nil when unset;
     # llm_context_strategy: the configured layers (LLMContextStrategy), nil when unset;
@@ -42,9 +43,9 @@ module Samagotchi
     # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
     # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, :models,
-                           keyword_init: true) do
+                           :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
+                           :window_tokens, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
+                           :models, keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.
       def chat? = api == :openai

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