samagotchi 0.77.0 → 0.78.0

data/lib/samagotchi/llm/anthropic_wire.rb

@@ -83,6 +83,28 @@ 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
+
       # +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:`.
     #
@@ -348,6 +351,30 @@ module Samagotchi
       # edit/write result's tool_diffs (never sent), an empty-answer
       # note's marker (TurnNote.empty, never sent), and an answer's display
       # and display_refs (AnswerDisplay, AnswerRefs; never sent).
+      # 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
+
       def plain(conversation)
         conversation.map do |entry|
           content = entry[:content].is_a?(Array) ? entry[:content] : entry[:content].to_s
@@ -649,11 +676,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 +691,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/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/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/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

data/lib/samagotchi/session_metrics.rb

@@ -144,6 +144,9 @@ module Samagotchi
       # (finish_reason length). `retries` counts the network's only.
       :cuts,
       :capped,
+      # Replayed thinking blocks a preserved-thinking recovery dropped
+      # (:generation_completed's thinking_dropped, ChatLoop).
+      :thinking_dropped,
       :model,
       # The model the turn ran on (asked host:model, :generation_started's
       # model_ref; the first generation's), and whether its open generation
@@ -505,6 +508,7 @@ module Samagotchi
         retries: totals.retries,
         cuts: totals.cuts,
         capped: totals.capped,
+        thinking_dropped: totals.thinking_dropped,
         started_at: @started_at,
         last_activity_at: @last_activity_at,
         # From the session's first start (an earlier process's too), to now.
@@ -589,6 +593,7 @@ module Samagotchi
           retries: 0,
           cuts: 0,
           capped: 0,
+          thinking_dropped: 0,
           model: nil,
           model_ref: nil,
           gen_switch: false,
@@ -679,12 +684,15 @@ module Samagotchi
       end
     end
 
+    # A generation's cut, output cap and dropped thinking blocks, into the turn.
     def count_cut(event)
       @mutex.synchronize do
         next unless @turn
 
         @turn.cuts += 1 if event[:stopped_by] && event[:stopped_by].to_s != "steer"
         @turn.capped += 1 if event[:finish_reason].to_s == "length"
+        dropped = event[:thinking_dropped]
+        @turn.thinking_dropped += dropped if dropped.is_a?(Integer) && dropped.positive?
       end
     end
 
@@ -872,6 +880,7 @@ module Samagotchi
       }
       fields[:cache_write_tokens_sum] = turn.cache_write_sum if turn.cache_write_sum.positive?
       fields[:reprefill_tokens_sum] = turn.reprefill_sum if turn.reprefill_sum.positive?
+      fields[:thinking_dropped] = turn.thinking_dropped if turn.thinking_dropped.positive?
       fields.merge!(cost: turn.cost_sum, cost_source: "reported") if turn.cost_sum
       fields[:cost_estimate] = turn.cost_estimate_sum if turn.cost_estimate_sum.positive?
       fields[:switch_prefill_tokens] = turn.switch_prefill_tokens if turn.switch_prefill_tokens

data/lib/samagotchi/terminal_ui/formatting.rb

@@ -600,6 +600,9 @@ module Samagotchi
         # A looped session: loop-guard's cuts, or thinking that ran to the cap.
         lines << "thinking cuts:    #{snapshot[:cuts].to_i}"
         lines << "output cap hits:  #{snapshot[:capped].to_i}"
+        # Claude 5.x: replayed thinking a prefix change made the API drop.
+        dropped = snapshot[:thinking_dropped].to_i
+        lines << "thinking dropped: #{dropped} blocks (preserved-thinking recovery)" if dropped.positive?
         context = snapshot[:context] || {}
         if context[:used_tokens]
           pct = context_pct_text(context, snapshot[:llm_context])

data/lib/samagotchi/terminal_ui.rb

@@ -42,8 +42,8 @@ require_relative "children_status"
 require_relative "log"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires this file (its worker
-  # process loads the whole UI stack through it), 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 in-process terminal front end (`chi --no-shared`, `chi scratch`,

data/lib/samagotchi/tools/delegate.rb

@@ -10,8 +10,8 @@ require_relative "delegate_wait"
 require_relative "../child_reports"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so these 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__)
 
   module Tools

data/lib/samagotchi/tools/delegate_result.rb

@@ -6,8 +6,8 @@ require_relative "delegate"
 require_relative "delegate_wait"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so these 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__)
 
   module Tools

data/lib/samagotchi/tools/list_sessions.rb

@@ -6,8 +6,8 @@ require_relative "../session"
 require_relative "peers"
 
 module Samagotchi
-  # Loaded on first use: session_manager requires terminal_ui, which
-  # requires KernelLoop and so these 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__)
 
   module Tools

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.77.0"
+  VERSION = "0.78.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end