samagotchi 0.77.0 → 0.79.0

data/lib/samagotchi/llm/anthropic_messages.rb

@@ -13,6 +13,7 @@ require_relative "openai_chat"
 require_relative "prompt_cache"
 require_relative "refusal_memo"
 require_relative "anthropic_assembly"
+require_relative "anthropic_binding_recovery"
 require_relative "anthropic_wire"
 require_relative "dialect"
 
@@ -36,6 +37,9 @@ module Samagotchi
     # broader refusal paths never see them:
     # - adaptive thinking (or output_config.effort) refused: the model gets
     #   the budget form instead (#budget_form), per model;
+    # - thinking off refused for the `between_tools` form (Claude 5.x:
+    #   `thinking: {type: "disabled"}` is refused, the 400 names
+    #   `between_tools`): that form from then on, per model;
     # - thinking.display refused (a provider whose thinking schema has no
     #   such field, e.g. Fireworks without its dialect): no display for the
     #   host, the thinking itself kept;
@@ -43,6 +47,11 @@ module Samagotchi
     #   breakpoints for the host;
     # - max_tokens over the model's output limit: the limit the message
     #   names, per model.
+    # A signature 400 (Claude 5.x preserved thinking: a replayed block bound
+    # to a prefix that changed) is recovered here too (AnthropicBindingRecovery):
+    # asked again with drop_block, or with the blocks stripped, and the
+    # dropped blocks handed to the loop (ChatResponse#thinking_drop), which
+    # removes them from the history.
     class AnthropicMessages
       include ModelListing
       include AdapterCommon
@@ -55,6 +64,10 @@ module Samagotchi
       # A 400 refusing adaptive thinking or its effort.
       ADAPTIVE_REFUSED_RE = /adaptive|output_config|effort/i
       CACHE_CONTROL_RE = /cache_control/i
+      # A 400 refusing `thinking: disabled` and naming the form that model
+      # takes for off: "To turn thinking off on this model, send "thinking":
+      # {"type": "between_tools"} instead of {"type": "disabled"}" (Claude 5.x).
+      THINKING_OFF_FORM_RE = /between_tools/i
       # A 400 refusing the thinking display field: its path (pydantic:
       # "thinking.adaptive.display"), or the field named as unknown or not
       # permitted. Not an error that only echoes the input
@@ -100,6 +113,7 @@ module Samagotchi
         # The 400 fixes (#refusal_fix): :thinking_form and :output_cap per
         # model, :thinking_display and :cache_control for the host.
         @refusals = RefusalMemo.new
+        @binding = AnthropicBindingRecovery.new(refusals: @refusals, host_name: @host_name, budget_form: method(:budget_form?))
         @http = build_http(timeout: timeout, open_timeout: open_timeout, retries: retries, retry_policy: retry_policy,
                            sleeper: sleeper, first_token_timeout: first_token_timeout,
                            api_key: ApiKey.for(api_key_env, host: @host_name, env: env, scheme: auth || @dialect.auth))
@@ -111,14 +125,29 @@ module Samagotchi
       def chat(messages:, model:, tools: [], cancel_controller: nil, on_delta: nil, on_retry: nil, options: {},
                session_id: nil)
         fixed = []
+        recovery = AnthropicBindingRecovery::Recovery.new(tried: [])
+        shown = false
         begin
-          body = request_body(messages, tools, model, options)
-          request = post_request("#{@base_url}/v1/messages", body, session_id: session_id)
+          # A rebuilt body (a refusal fix's retry) keeps the recovery.
+          body, stripped = @binding.recovered_body(request_body(messages, tools, model, options), recovery)
+          headers = recovery.step == :drop_block ? { "anthropic-beta" => AnthropicBindingRecovery::BINDING_BETA } : {}
+          request = post_request("#{@base_url}/v1/messages", body, session_id: session_id, extra_headers: headers)
           log_fields = { model: model, purpose: @purpose, sampling: sampling_summary(body), cache: cache_summary(body) }
-          return chat_once(request, cancel_controller, log_fields) unless @stream
-
-          chat_streamed(request, cancel_controller, on_delta, on_retry, log_fields)
+          response, transformations =
+            if @stream
+              chat_streamed(request, cancel_controller, on_delta, on_retry, log_fields, -> { shown = true })
+            else
+              chat_once(request, cancel_controller, log_fields)
+            end
+          recovery.step ? @binding.with_thinking_drop(response, recovery, body, stripped, transformations, model) : response
         rescue BadRequest => e
+          # Only before anything was shown: a mid-stream error must not
+          # repeat its deltas.
+          if !shown && @binding.advance(e, body, recovery, model)
+            recovery.tried << recovery.step
+            retry
+          end
+
           fix = refusal_fix(e, body, model)
           raise if fix.nil? || fixed.include?(fix)
 
@@ -161,16 +190,18 @@ module Samagotchi
       # @return [Hash] frozen
       def thinking_off_refused_fields = thinking_fields(:low)
 
+      # Whether +model+ gets the budget form (it refused adaptive thinking).
+      def budget_form?(model) = @refusals.refused?(:thinking_form, model.to_s)
+
       # The host's models, every page: GET {base}/v1/models with
       # limit=1000 and after_id paging (has_more/last_id). Anthropic's shape
       # (max_input_tokens, max_tokens, capabilities) and the OpenAI shape a
       # gateway or Splash serves here are both read (ModelListing).
-      # Whether +model+ gets the budget form (it refused adaptive thinking).
-      def budget_form?(model) = @refusals.refused?(:thinking_form, model.to_s)
-
       # @return [Array<ModelInfo>]
       def list_models
-        list_model_pages { |after| URI("#{@base_url}/v1/models?#{URI.encode_www_form({ limit: 1000, after_id: after }.compact)}") }
+        list_model_pages(headers: { "anthropic-version" => API_VERSION }) do |after|
+          URI("#{@base_url}/v1/models?#{URI.encode_www_form({ limit: 1000, after_id: after }.compact)}")
+        end
       end
 
       private
@@ -189,6 +220,7 @@ module Samagotchi
       def request_body(messages, tools, model, options)
         options = (options || {}).to_h.transform_keys(&:to_sym).except(*DROPPED_OPTIONS)
         options = budget_form(options) if budget_form?(model)
+        options = thinking_between_tools(options) if @refusals.refused?(:thinking_off_form, model.to_s)
         options = without_display(options) if @refusals.refused?(:thinking_display)
         cache = PromptCache.control if @purpose == "chat" && @dialect.cache_breakpoints && !@refusals.refused?(:cache_control)
         translated = AnthropicWire.translate(messages, cache: cache)
@@ -221,6 +253,16 @@ module Samagotchi
                       output_config: config.empty? ? nil : config)
       end
 
+      # +options+ with thinking off as the form such a model takes:
+      # `thinking: {type: "between_tools"}` where `disabled` was asked (a
+      # model that refused `disabled`).
+      def thinking_between_tools(options)
+        thinking = options[:thinking]
+        return options unless thinking.is_a?(Hash) && thinking.transform_keys(&:to_sym)[:type].to_s == "disabled"
+
+        options.merge(thinking: thinking.transform_keys(&:to_sym).merge(type: "between_tools"))
+      end
+
       # +options+ with no thinking.display (the host refused the field).
       def without_display(options)
         thinking = options[:thinking]
@@ -269,6 +311,11 @@ module Samagotchi
           @refusals.remember(:thinking_form, model.to_s)
           Log.info(:http, "thinking_form_switched", host: @host_name, model: model.to_s, to: "budget", detail: detail[0, 200])
           :thinking_form
+        elsif body.dig(:thinking, :type) == "disabled" && THINKING_OFF_FORM_RE.match?(detail)
+          @refusals.remember(:thinking_off_form, model.to_s)
+          Log.info(:http, "thinking_off_form_switched", host: @host_name, model: model.to_s, to: "between_tools",
+                                                        detail: detail[0, 200])
+          :thinking_off_form
         elsif !@refusals.refused?(:cache_control) && CACHE_CONTROL_RE.match?(detail) && cache_summary(body)
           @refusals.remember(:cache_control)
           Log.info(:http, "cache_control_refused", host: @host_name, detail: detail[0, 200])
@@ -309,30 +356,40 @@ module Samagotchi
         raise error if error
         raise ProtocolError.new("#{@host_name}: no content in the Messages response", host: @host_name) unless message?(body)
 
-        AnthropicAssembly.from_message(body).response
+        assembly = AnthropicAssembly.from_message(body)
+        [assembly.response, assembly.input_transformations]
       end
 
       def message?(body) = body.is_a?(Hash) && body["content"].is_a?(Array)
 
       # The SSE stream: each `data:` event goes through the assembly (the
       # `event:` lines are not needed, so a gateway that drops them works);
-      # on_delta gets every event but pings, with its text and reasoning.
-      def chat_streamed(request, cancel_controller, on_delta, on_retry, log_fields)
-        stream_assembled(request, cancel_controller, on_retry, log_fields, assembly_class: AnthropicAssembly,
-                                                                           what: "stream event") do |assembly, event, shown|
+      # on_delta gets every event but pings, with its text and reasoning;
+      # +on_shown+ hears each event that shows something. Returns the
+      # response and the message's input_transformations.
+      def chat_streamed(request, cancel_controller, on_delta, on_retry, log_fields, on_shown = nil)
+        last = nil
+        response = stream_assembled(request, cancel_controller, on_retry, log_fields, assembly_class: AnthropicAssembly,
+                                                                                      what: "stream event") do |assembly, event, shown|
+          last = assembly
           content, reasoning = assembly.add(event)
-          shown.call if AnthropicAssembly.shows?(event)
+          if AnthropicAssembly.shows?(event)
+            shown.call
+            on_shown&.call
+          end
           on_delta&.call(content: content, reasoning: reasoning, payload: assembly.with_usage(event)) unless event["type"] == "ping"
         end
+        [response, last&.input_transformations || []]
       end
 
-      def post_request(url, body, session_id: nil)
+      # +extra_headers+ go after the defaults (the binding beta).
+      def post_request(url, body, session_id: nil, extra_headers: {})
         headers = { "anthropic-version" => API_VERSION }
         unless session_id.to_s.empty?
           headers["Session-Id"] = session_id.to_s
           headers[@dialect.session_header] = session_id.to_s if @dialect.session_header
         end
-        json_post(url, body, headers)
+        json_post(url, body, headers.merge(extra_headers))
       end
     end
   end

data/lib/samagotchi/llm/anthropic_wire.rb

@@ -32,8 +32,10 @@ module Samagotchi
       TOOL_ID_INVALID = /[^a-zA-Z0-9_-]/
       # What Messages takes as a tool name.
       TOOL_NAME = /\A[a-zA-Z0-9_-]{1,128}\z/
+      # The content block types a model's thinking is replayed in.
+      THINKING_TYPES = %w[thinking redacted_thinking].freeze
       # Blocks that can't carry a cache_control breakpoint.
-      UNMARKABLE = %w[thinking redacted_thinking].freeze
+      UNMARKABLE = THINKING_TYPES
 
       # A request's system blocks and messages.
       Translated = Data.define(:system, :messages)
@@ -83,6 +85,32 @@ module Samagotchi
         end
       end
 
+      # A replayed thinking block's identity, the one name the adapter and
+      # ChatLoop share for it: a thinking block's signature, a
+      # redacted_thinking block's data, or, when that is empty (Splash
+      # sends signature ""), "text:" + the SHA256 of its thinking text. nil
+      # for any other block and for one with neither (never matched).
+      # String or symbol keys.
+      def block_identity(block)
+        return nil unless block.is_a?(Hash)
+
+        case type_of(block)
+        when "thinking"
+          signature = (block["signature"] || block[:signature]).to_s
+          return signature unless signature.empty?
+
+          text = (block["thinking"] || block[:thinking]).to_s
+          text.empty? ? nil : "text:#{Digest::SHA256.hexdigest(text)}"
+        when "redacted_thinking"
+          data = (block["data"] || block[:data]).to_s
+          data.empty? ? nil : data
+        end
+      end
+
+      # Whether +block+ is a thinking or redacted_thinking block (a Hash,
+      # string or symbol keys).
+      def thinking_block?(block) = block.is_a?(Hash) && THINKING_TYPES.include?(type_of(block))
+
       # +id+ as Messages takes it (^[a-zA-Z0-9_-]+$), the same in tool_use
       # and tool_result: a valid id as it is, another with its invalid
       # characters replaced and a short hash of it appended (so "a.b" and

data/lib/samagotchi/llm/chat_loop.rb

@@ -7,6 +7,7 @@ require_relative "model_result"
 require_relative "errors"
 require_relative "usage"
 require_relative "openai_chat"
+require_relative "anthropic_wire"
 require_relative "native_tool_normalizer"
 require_relative "refusal_memo"
 require_relative "stream_drops"
@@ -41,7 +42,9 @@ module Samagotchi
     #
     # Stream events match the native loop's: :generation_started (with the
     # context window), :generation_chunk per delta, :generation_completed,
-    # :generation_retrying, the tool-call events and :pending_input_merged.
+    # :generation_retrying, the tool-call events and :pending_input_merged,
+    # and :thinking_dropped after a preserved-thinking recovery
+    # (#settle_dropped_thinking!).
     # A chunk carries `thinking:` (reasoning deltas), `text:` (answer deltas)
     # and `content:` (both, like native raw content) plus the raw `payload:`.
     #
@@ -339,6 +342,30 @@ module Samagotchi
         nil
       end
 
+      # Removes the replayed thinking blocks a response's ThinkingDrop
+      # names (AnthropicWire.block_identity) from the model entries'
+      # anthropic_content: the edit the provider made for that request, so
+      # the next one is valid as it is. Each changed entry is replaced in
+      # place, at its index (the Run, ContextStatus and the LLM context
+      # turn hold the array and its indexes); one left with no blocks loses
+      # the key. +thinking+ (the text the UIs show) stays.
+      # @return [Integer] the blocks removed
+      def settle_dropped_thinking!(conversation, identities)
+        wanted = Array(identities)
+        removed = 0
+        conversation.each_with_index do |entry, index|
+          blocks = entry[:anthropic_content]
+          next unless blocks.is_a?(Array)
+
+          kept = blocks.reject { |block| (identity = AnthropicWire.block_identity(block)) && wanted.include?(identity) }
+          next if kept.size == blocks.size
+
+          removed += blocks.size - kept.size
+          conversation[index] = kept.empty? ? entry.except(:anthropic_content) : entry.merge(anthropic_content: kept)
+        end
+        removed
+      end
+
       # 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, sent back as #wire_messages says), a result's tool_call_id, the image
@@ -444,8 +471,6 @@ module Samagotchi
 
       def thought?(entry) = entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?
 
-      THINKING_BLOCKS = %w[thinking redacted_thinking].freeze
-
       # A model entry's saved blocks (anthropic_content) to send back
       # verbatim, for an adapter that replays them: nil when there are none,
       # for an interrupted entry (its partial blocks have no signature), and
@@ -458,7 +483,7 @@ module Samagotchi
         return nil unless replays_content? && blocks.is_a?(Array) && !blocks.empty? && !entry[:interrupted]
         return nil unless Array(entry[:tool_calls]).all? { |call| paired.include?(call[:id]) }
 
-        blocks = blocks.reject { |block| block.is_a?(Hash) && THINKING_BLOCKS.include?((block["type"] || block[:type]).to_s) } unless keep_thinking
+        blocks = blocks.reject { |block| AnthropicWire.thinking_block?(block) } unless keep_thinking
         blocks.empty? ? nil : blocks
       end
 
@@ -492,6 +517,17 @@ module Samagotchi
           # The empty generations, never saved: the UIs draw the turn's
           # steps from them (ModelResult#empty_steps).
           @empty_steps = []
+          # Set as the run goes: the last response's refusal, the context
+          # window the last request was sized for, that request's text and
+          # image estimates, whether a refused reasoning is being asked
+          # again without it, and whether a preserved-thinking recovery
+          # settled nothing once already.
+          @refusal = nil
+          @window = nil
+          @request_chars = nil
+          @request_image_tokens = nil
+          @without_reasoning = false
+          @recovery_repeated = false
           @context = ContextStatus.new(conversation: conversation, llm_context: loop.llm_context)
           loop.llm_context_turn = LLMContextForget::Turn.new(conversation: conversation, context: @context,
                                                              emit: method(:emit))
@@ -649,11 +685,13 @@ module Samagotchi
 
             return cut_response(iteration, thought, generation_controller.detail || {})
           end
+          dropped = settle_thinking_drop(iteration, response.thinking_drop)
           record_context_status(response.usage, window)
           emit(type: :generation_completed, iteration: iteration, content_length: response.text.length,
                thinking_chars: response.reasoning.to_s.length, served_model: response.model,
                served_provider: response.provider, requested_model: @model_name, finish_reason: response.finish_reason,
-               **(response.usage&.cache_fields || {}), **reprefill_field(response.usage))
+               **(response.usage&.cache_fields || {}), **reprefill_field(response.usage),
+               **(dropped.positive? ? { thinking_dropped: dropped } : {}))
           dump_response(response, iteration)
           @loop.fire_hook(:after_generation, { type: :after_generation, iteration: iteration, response: response.text,
                                                messages: AnswerDisplay.strip_all(@conversation).map(&:dup).freeze })
@@ -662,6 +700,24 @@ module Samagotchi
           [e.reason, streamed, thought]
         end
 
+        # A response the adapter got by dropping replayed thinking blocks
+        # (ChatResponse#thinking_drop): those blocks leave the stored
+        # entries (before this step adds its own, whatever its finish
+        # reason), and :thinking_dropped says how many. A drop that settles
+        # nothing (the same blocks again: they were settled, then came back)
+        # is logged once per run. Returns the blocks dropped.
+        def settle_thinking_drop(iteration, drop)
+          return 0 unless drop && !drop.identities.empty?
+
+          count = drop.identities.size
+          if @loop.settle_dropped_thinking!(@conversation, drop.identities).zero? && !@recovery_repeated
+            @recovery_repeated = true
+            Log.info(:model, "thinking_recovery_repeated", model: @model_name.to_s, how: drop.how.to_s, blocks: count)
+          end
+          emit(type: :thinking_dropped, iteration: iteration, count: count, how: drop.how)
+          count
+        end
+
         # The request's re-prefilled tokens (KernelLoop#reprefilled_tokens).
         def reprefill_field(usage)
           return {} unless usage&.source == :server

data/lib/samagotchi/llm/errors.rb

@@ -38,17 +38,19 @@ module Samagotchi
     #                    whatever status; also raised before sending)
     #   ProtocolError    a body that isn't what the API promises
     class ProviderError < StandardError
-      attr_reader :host, :status, :retry_after
+      attr_reader :host, :status, :retry_after, :diagnosis
       attr_accessor :attempts
 
       # @param host [String, nil] the host (or server label) that failed
       # @param status [Integer, nil] the HTTP status, when there was one
       # @param retry_after [Float, nil] seconds the server asked to wait
-      def initialize(message = nil, host: nil, status: nil, retryable: nil, retry_after: nil, attempts: 1)
+      # @param diagnosis [String, nil] an optional provider diagnosis header
+      def initialize(message = nil, host: nil, status: nil, retryable: nil, retry_after: nil, diagnosis: nil, attempts: 1)
         @host = host
         @status = status
         @retryable = retryable.nil? ? default_retryable? : retryable
         @retry_after = retry_after
+        @diagnosis = diagnosis
         @attempts = attempts
         super(message)
       end
@@ -402,10 +404,10 @@ module Samagotchi
       # @param status [Integer]
       # @param body [String] the response body (JSON or text)
       # @param retry_after [String, nil] the Retry-After header
-      def from_response(status:, body:, host:, retry_after: nil)
+      def from_response(status:, body:, host:, retry_after: nil, diagnosis: nil)
         message = error_message(body)
         text = "#{host}: HTTP #{status}: #{message}"
-        options = { host: host, status: status }
+        options = { host: host, status: status, diagnosis: diagnosis }
         if CONTEXT_OVERFLOW_RE.match?(message) || CONTEXT_OVERFLOW_RE.match?(body.to_s)
           return BadRequest.new(text, context_overflow: true, **options)
         end

data/lib/samagotchi/llm/http.rb

@@ -417,7 +417,8 @@ module Samagotchi
         return if status.between?(200, 299)
 
         error = ProviderErrors.from_response(status: status, body: response.body.to_s, host: @label,
-                                             retry_after: response["Retry-After"])
+                                             retry_after: response["Retry-After"],
+                                             diagnosis: response["anthropic-thinking-prefix-mismatch"])
         error.hint ||= @api_key ? @api_key.hint : ApiKey.missing_hint(@label) if error.is_a?(AuthError)
         raise error
       end

data/lib/samagotchi/llm/model_listing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../log"
+
 module Samagotchi
   module LLM
     # A model a host lists. Unknown fields are nil.
@@ -51,7 +53,10 @@ module Samagotchi
 
       def init_model_listing(models_ttl)
         @models_ttl = models_ttl
+        @models_failure_ttl = [models_ttl, 60].min
         @models_mutex = Mutex.new
+        @models_failure_at = nil
+        @models_failure_logged_at = nil
       end
 
       # +model+'s entry in the cached list: its exact id, else any case.
@@ -93,16 +98,39 @@ module Samagotchi
       end
 
       def cached_models
+        now = monotonic
         @models_mutex.synchronize do
-          fresh = @models_at && (monotonic - @models_at) < @models_ttl
+          fresh = @models_at && (now - @models_at) < @models_ttl
           return @models if fresh
+
+          failed_recently = @models_failure_at && (now - @models_failure_at) < @models_failure_ttl
+          return [] if failed_recently
         end
         models = list_models
         @models_mutex.synchronize do
           @models = models
           @models_at = monotonic
+          @models_failure_at = nil
         end
         models
+      rescue StandardError => e
+        @models_mutex.synchronize { @models_failure_at = monotonic }
+        log_model_listing_failure(e)
+        raise
+      end
+
+      def log_model_listing_failure(error)
+        now = monotonic
+        should_log = @models_mutex.synchronize do
+          next false if @models_failure_logged_at && (now - @models_failure_logged_at) < @models_ttl
+
+          @models_failure_logged_at = now
+          true
+        end
+        return unless should_log
+
+        host = @host_name.to_s.empty? ? @base_url : @host_name
+        Log.warn(:model, "list_failed", host: host, error: error.class.name, msg: error.message.to_s[0, 500])
       end
 
       def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)

data/lib/samagotchi/llm/openai_chat.rb

@@ -37,12 +37,22 @@ module Samagotchi
     # +stop_details+: why the provider stopped, when it says more than the
     # finish reason (Messages' stop_details on a refusal: type, category,
     # explanation; string keys); nil otherwise.
+    # +thinking_drop+: the replayed thinking blocks the provider dropped (or
+    # the adapter stripped) to answer a request whose history it had
+    # refused (ThinkingDrop, AnthropicMessages' binding recovery); nil
+    # otherwise.
     ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :provider, :cut,
-                               :top_logprobs, :provider_content, :stop_details) do
+                               :top_logprobs, :provider_content, :stop_details, :thinking_drop) do
       def initialize(model: nil, provider: nil, cut: nil, top_logprobs: [].freeze, provider_content: nil, stop_details: nil,
-                     **fields) = super
+                     thinking_drop: nil, **fields) = super
     end
 
+    # Replayed thinking blocks a request went through without: their
+    # identities (AnthropicWire.block_identity, a frozen Array) and +how+:
+    # :drop_block (the provider dropped them, prefix_binding_mismatch) or
+    # :strip (the adapter removed them from the body).
+    ThinkingDrop = Data.define(:identities, :how)
+
     # One alternative for an answer token: its text and log probability.
     TokenLogprob = Data.define(:token, :logprob) do
       # The first token's alternatives in a chat completion body's

data/lib/samagotchi/llm/refusal_memo.rb

@@ -6,8 +6,9 @@ module Samagotchi
     # host's, HostRegistry keeps one per worker; ChatLoop: the worker's): a
     # +kind+ (a Symbol) for one model, or for the whole host when the model
     # is nil, with a value (true, or what the refusal named: an output cap).
-    # The turn, side-ask and recap threads share a holder, so every read and
-    # write takes the lock.
+    # The turn thread and the model-list reads share HostRegistry's adapter
+    # (an IdleClient's adapter is its own), so every read and write takes the
+    # lock.
     class RefusalMemo
       def initialize
         @mutex = Mutex.new

data/lib/samagotchi/note_delivery.rb

@@ -4,8 +4,8 @@ require_relative "session"
 require_relative "session_inbox"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools (a require cycle otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
   # The one rule for putting a context note into a session, shared by

data/lib/samagotchi/plugin/sessions.rb

@@ -9,8 +9,8 @@ require_relative "../tools/delegate"
 require_relative "../children_status"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires the Engine and so the plugins (a require cycle otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("../session_manager", __dir__)
 
   module Plugin

data/lib/samagotchi/question_desk.rb

@@ -349,7 +349,7 @@ module Samagotchi
         @pending = pending = pending.with(relayed_to: relayed_to)
         if session
           session.pending_question = pending
-          begin; session.save(state_dir: state_dir); rescue StandardError; nil; end
+          save_session(session)
         end
         pending.id
       end
@@ -439,7 +439,7 @@ module Samagotchi
       end
       if session
         session.pending_question = pending
-        begin; session.save(state_dir: state_dir); rescue StandardError; nil; end
+        save_session(session)
       end
       event = { type: :question_requested, pending_question: pending.to_h }
       event[:standing] = true if standing
@@ -559,12 +559,19 @@ module Samagotchi
     def cancel_controller = @cancel_controller_lookup.call
     def emit(event) = @emit.call(event)
 
+    def save_session(session)
+      session.save(state_dir: state_dir)
+    rescue StandardError => e
+      Log.warn(:turn, "question_save_failed", sid: session.id, error: e.class.name, msg: e.message.to_s[0, 200])
+      nil
+    end
+
     # The session file no longer holds a pending question.
     def clear_saved_question
       return unless session
 
       session.pending_question = nil
-      begin; session.save(state_dir: state_dir); rescue StandardError; nil; end
+      save_session(session)
     end
   end
 end

data/lib/samagotchi/reasoning_history.rb

@@ -2,6 +2,7 @@
 
 require_relative "config"
 require_relative "setting_explained"
+require_relative "llm/anthropic_wire"
 
 module Samagotchi
   # Which of its own reasoning a chat host's model gets back
@@ -125,7 +126,7 @@ module Samagotchi
         next false unless entry[:role].to_s == "model"
 
         (entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?) ||
-          Array(entry[:anthropic_content]).any? { |block| block.is_a?(Hash) && %w[thinking redacted_thinking].include?(block["type"].to_s) }
+          Array(entry[:anthropic_content]).any? { |block| LLM::AnthropicWire.thinking_block?(block) }
       end
     end
 

data/lib/samagotchi/reply_wait.rb

@@ -6,9 +6,8 @@ require_relative "session_inbox"
 require_relative "worker_sidecar"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so the tools that use this (a require cycle
-  # otherwise).
+  # Loaded on first use: this autoload keeps SessionManager and its ~80
+  # files unloaded until the delegate/session path needs them.
   autoload :SessionManager, File.expand_path("session_manager", __dir__)
 
   # Waiting for a session's next reply. A reply is the worker's

data/lib/samagotchi/session_manager.rb

@@ -37,7 +37,6 @@ require_relative "plugin_session_state"
 require_relative "context_sources"
 require_relative "session_chain"
 require_relative "child_move"
-require_relative "terminal_ui"
 
 module Samagotchi
   # SessionManager coordinates background session processes.

data/lib/samagotchi/session_metrics/totals.rb

@@ -8,7 +8,7 @@ module Samagotchi
     # mid-turn. The tool tallies (by tool, aliased, errors) are counted per
     # tool record, not per turn: SessionMetrics keeps those apart.
     class Totals < Data.define(
-      :cancellations, :iterations, :gen_ms, :retries, :cuts, :capped,
+      :cancellations, :iterations, :gen_ms, :retries, :cuts, :capped, :thinking_dropped,
       :prompt_sum, :completion_sum, :cached_sum, :cache_write_sum, :reprefill_sum, :reasoning_sum,
       :cost_sum, :cost_estimate_sum, :decode_ms_sum, :decode_tokens_sum,
       # The newest speeds a record has, and where the decode one came from.
@@ -19,7 +19,8 @@ module Samagotchi
       # The record keys each sum adds up (a turn record's own names).
       RECORD_SUMS = {
         prompt_sum: :prompt_tokens_sum, completion_sum: :completion_tokens, iterations: :iterations,
-        gen_ms: :gen_ms, retries: :retries, cuts: :cuts, capped: :capped, cached_sum: :cached_tokens_sum,
+        gen_ms: :gen_ms, retries: :retries, cuts: :cuts, capped: :capped, thinking_dropped: :thinking_dropped,
+        cached_sum: :cached_tokens_sum,
         cache_write_sum: :cache_write_tokens_sum, reprefill_sum: :reprefill_tokens_sum,
         reasoning_sum: :reasoning_tokens, cost_sum: :cost, cost_estimate_sum: :cost_estimate,
         decode_ms_sum: :decode_ms, decode_tokens_sum: :decode_tokens
@@ -28,7 +29,7 @@ module Samagotchi
       # The running turn's (TurnState) counters each sum adds while it runs.
       TURN_SUMS = {
         iterations: :iteration_count, gen_ms: :gen_latency_accum, retries: :retries, cuts: :cuts,
-        capped: :capped, prompt_sum: :prompt_sum, completion_sum: :completion_sum, cached_sum: :cached_sum,
+        capped: :capped, thinking_dropped: :thinking_dropped, prompt_sum: :prompt_sum, completion_sum: :completion_sum, cached_sum: :cached_sum,
         cache_write_sum: :cache_write_sum, reprefill_sum: :reprefill_sum, reasoning_sum: :reasoning_sum,
         cost_sum: :cost_sum, cost_estimate_sum: :cost_estimate_sum, decode_ms_sum: :decode_ms_sum,
         decode_tokens_sum: :decode_tokens_sum