samagotchi 0.76.0 → 0.78.0

data/lib/samagotchi/guardrails/parent_approvals.rb

@@ -93,7 +93,7 @@ module Samagotchi
       # guardrail rules or approvals: by its rule, its paths or its command
       # (the dirs as this process's environment and config.yml name them).
       def protected?(pending)
-        facts = fetch(pending, :approval)
+        facts = pending.approval
         return false unless facts.is_a?(Hash)
         return true if PROTECTED_RULES.include?(fetch(facts, :rule).to_s)
         return true if fetch(facts, :source).to_s == ProtectedPaths::SOURCE
@@ -137,13 +137,13 @@ module Samagotchi
 
       # An approval: its kind says so, or it carries approval facts.
       def approval?(pending)
-        fetch(pending, :kind).to_s == Approval::KIND || !fetch(pending, :approval).nil?
+        pending.kind.to_s == Approval::KIND || !pending.approval.nil?
       end
 
       # The offered scopes, in option order, or nil when they are missing,
       # empty, not strings, or leave no option after them for Deny.
       def scopes(pending)
-        facts = fetch(pending, :approval)
+        facts = pending.approval
         scopes = facts.is_a?(Hash) ? fetch(facts, :scopes) : nil
         return nil unless scopes.is_a?(Array) && !scopes.empty? && scopes.all?(String)
         return nil unless scopes.size < options(pending).size
@@ -160,7 +160,7 @@ module Samagotchi
         index == options.size - 1 && options[index].to_s == Approval::DENY
       end
 
-      def options(pending) = Array(fetch(pending, :options))
+      def options(pending) = Array(pending.options)
 
       def fetch(hash, key)
         return nil unless hash.is_a?(Hash)

data/lib/samagotchi/guardrails/parent_continue.rb

@@ -24,12 +24,12 @@ module Samagotchi
       end
 
       # Why a parent may not give this answer, or nil.
-      # @param pending [Hash] the pending question (symbol or string keys)
+      # @param pending [PendingQuestion] the pending question
       # @param selected [Array<String>] the selected labels
       # @return [Symbol, nil] :stop_only
       def refusal(pending, selected, allowed: allowed?)
         return nil if allowed
-        return nil unless (pending[:kind] || pending["kind"]).to_s == KIND
+        return nil unless pending.kind.to_s == KIND
 
         Array(selected).map(&:to_s).include?(CONTINUE) ? :stop_only : nil
       end

data/lib/samagotchi/llm/anthropic_assembly.rb

@@ -44,14 +44,22 @@ module Samagotchi
         @stop_reason = nil
         @stop_details = nil
         @model = nil
+        @input_transformations = []
       end
 
+      # The message's input_transformations (Claude 5.x: what the API did to
+      # the request before generating, e.g. the thinking blocks drop_block
+      # dropped), as sent (string keys); [] when it named none. The paths
+      # index into the request body, which only the adapter holds.
+      attr_reader :input_transformations
+
       # A whole message: its model, usage, stop reason and blocks.
       def add_message(message)
         return unless message.is_a?(Hash)
 
         @model = served(message["model"]) || @model
         merge_usage(message["usage"])
+        read_transformations(message)
         @stop_reason = message["stop_reason"] if message["stop_reason"]
         @stop_details = message["stop_details"] if message["stop_details"].is_a?(Hash)
         Array(message["content"]).each { |block| @blocks << block.dup if block.is_a?(Hash) }
@@ -133,9 +141,15 @@ module Samagotchi
 
         @model = served(message["model"]) || @model
         merge_usage(message["usage"])
+        read_transformations(message)
         ["", ""]
       end
 
+      def read_transformations(message)
+        entries = message["input_transformations"]
+        @input_transformations = entries.select { |entry| entry.is_a?(Hash) } if entries.is_a?(Array)
+      end
+
       def start_block(index, block)
         return ["", ""] unless block.is_a?(Hash)
 

data/lib/samagotchi/llm/anthropic_messages.rb

@@ -43,6 +43,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 (#binding_recovery):
+    # 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
@@ -71,6 +76,27 @@ module Samagotchi
       # (configured sampling passes as written).
       DROPPED_OPTIONS = %i[reasoning_effort chat_template_kwargs stream_options prompt_cache_key logprobs top_logprobs
                            max_completion_tokens].freeze
+      # The beta header thinking.block_binding needs, and the behaviour the
+      # recovery asks for: the API drops a thinking block whose prefix
+      # changed (and every thinking block after it) for that request.
+      BINDING_BETA = "thinking-binding-controls-2026-08-01"
+      DROP_BLOCK = { prefix_mismatch_behavior: "drop_block" }.freeze
+      # A signature 400 that drop_block can settle: the block is valid but
+      # bound to another prefix. Without it the signature itself is bad
+      # (tampered, unreadable, another provider's): only a strip helps.
+      BOUND_ELSEWHERE_RE = /bound to a different conversation/i
+      # The block a signature 400 names: an index into the body sent.
+      BLOCK_PATH_RE = /messages\.(\d+)\.content\.(\d+)/
+      THINKING_TYPES = %w[thinking redacted_thinking].freeze
+      # The only drop the loop settles: a model_binding_mismatch (a /model
+      # downgrade) keeps its blocks, a switch back reads them again.
+      PREFIX_DROP = "prefix_binding_mismatch"
+
+      # One request's binding recovery (#binding_recovery): the step taken
+      # (nil, :drop_block or :strip), the steps tried, where a strip starts
+      # ([message, block] in the body), the last signature 400 and the body
+      # it answered, and the first 400's last sentence and diagnosis for the log line.
+      Recovery = Struct.new(:step, :tried, :strip_from, :signature, :why, :diagnosis)
 
       attr_reader :base_url, :host_name, :api_key_env, :models_ttl, :first_token_timeout, :dialect
 
@@ -111,14 +137,29 @@ module Samagotchi
       def chat(messages:, model:, tools: [], cancel_controller: nil, on_delta: nil, on_retry: nil, options: {},
                session_id: nil)
         fixed = []
+        recovery = 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 = recovered_body(request_body(messages, tools, model, options), recovery)
+          headers = recovery.step == :drop_block ? { "anthropic-beta" => 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 ? 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_recovery(e, body, recovery, model)
+            recovery.tried << recovery.step
+            retry
+          end
+
           fix = refusal_fix(e, body, model)
           raise if fix.nil? || fixed.include?(fix)
 
@@ -249,6 +290,152 @@ module Samagotchi
         body.merge(max_tokens: max_tokens, thinking: thinking.merge(budget_tokens: budget))
       end
 
+      # The step a signature 400 for +body+ takes (set on +recovery+, once
+      # each per request), or nil: the error goes on as it is.
+      # - drop_block: the same body with thinking.block_binding and the beta
+      #   header, for a block bound to another prefix, when the host takes
+      #   the controls and the body's thinking can carry them (adaptive,
+      #   enabled, or none: then adaptive; not disabled, nor none for a
+      #   model on the budget form);
+      # - strip: the block the 400 names (else the first replayed thinking
+      #   block) and every thinking block after it removed, for a bad
+      #   signature, where drop_block can't apply, when the host refused
+      #   the controls (remembered for the host), or after a second
+      #   signature 400.
+      def binding_recovery(error, body, recovery, model)
+        return nil if body.nil? || error.status != 400
+
+        if error.thinking_binding_unsupported? && recovery.step == :drop_block
+          unless @refusals.refused?(:binding_controls)
+            @refusals.remember(:binding_controls)
+            Log.info(:http, "binding_controls_refused", host: @host_name, detail: error.detail.to_s[0, 200])
+          end
+          return strip_step(recovery)
+        end
+        return nil unless error.thinking_signature?
+
+        recovery.diagnosis ||= error.diagnosis
+        recovery.signature = [error.detail.to_s, body]
+        case recovery.step
+        when nil
+          return nil if thinking_positions(body).empty?
+
+          recovery.why = last_sentence(error.detail.to_s)
+          return strip_step(recovery) unless drop_block_fits?(error, body, model)
+
+          recovery.step = :drop_block
+        when :drop_block then strip_step(recovery)
+        end
+      end
+
+      def drop_block_fits?(error, body, model)
+        return false unless BOUND_ELSEWHERE_RE.match?(error.detail.to_s) && !@refusals.refused?(:binding_controls)
+
+        case body[:thinking]
+        when nil then !budget_form?(model)
+        when Hash then %w[adaptive enabled].include?(body[:thinking][:type].to_s)
+        else false
+        end
+      end
+
+      # The strip, from the block the last signature 400 names in the body
+      # it answered (a thinking block there), else the first replayed one.
+      def strip_step(recovery)
+        return nil if recovery.tried.include?(:strip)
+
+        detail, body = recovery.signature
+        positions = thinking_positions(body)
+        named = detail.to_s.match(BLOCK_PATH_RE)&.captures&.map(&:to_i)
+        recovery.strip_from = positions.include?(named) ? named : positions.first
+        recovery.step = recovery.strip_from && :strip
+      end
+
+      # [message, block] of every thinking or redacted_thinking block in
+      # +body+'s messages.
+      def thinking_positions(body)
+        Array(body[:messages]).each_with_index.flat_map do |message, n|
+          Array(message[:content]).each_with_index.filter_map { |block, m| [n, m] if thinking_block?(block) }
+        end
+      end
+
+      def thinking_block?(block) = block.is_a?(Hash) && THINKING_TYPES.include?((block["type"] || block[:type]).to_s)
+
+      # +body+ as the recovery step sends it, and the identities a strip
+      # removed (nil for none).
+      def recovered_body(body, recovery)
+        case recovery.step
+        when :drop_block then [body.merge(thinking: drop_block_thinking(body[:thinking])), nil]
+        when :strip then stripped_body(body, recovery.strip_from)
+        else [body, nil]
+        end
+      end
+
+      # The body's thinking with block_binding: drop_block (adaptive
+      # without one: the binding controls need adaptive or enabled).
+      def drop_block_thinking(thinking)
+        thinking = thinking.is_a?(Hash) ? thinking.transform_keys(&:to_sym) : {}
+        thinking = { type: "adaptive" } unless %w[adaptive enabled].include?(thinking[:type].to_s)
+        thinking.merge(block_binding: DROP_BLOCK)
+      end
+
+      # +body+ without the thinking blocks from +from+ on (a trailing run:
+      # what Messages takes; a gap in the middle it refuses), and their
+      # identities. A message left empty says the placeholder.
+      def stripped_body(body, from)
+        first_message, first_block = from
+        removed = []
+        messages = body[:messages].each_with_index.map do |message, n|
+          next message if n < first_message
+
+          content = message[:content].each_with_index.reject do |block, m|
+            drop = (n > first_message || m >= first_block) && thinking_block?(block)
+            removed << AnthropicWire.block_identity(block) if drop
+            drop
+          end.map(&:first)
+          next message if content.size == message[:content].size
+
+          message.merge(content: content.empty? ? [{ type: "text", text: AnthropicWire::PLACEHOLDER }] : content)
+        end
+        [body.merge(messages: messages), removed.compact.uniq.freeze]
+      end
+
+      # +response+ with the blocks this request went without
+      # (ThinkingDrop), logged: a strip's, or drop_block's
+      # prefix_binding_mismatch entries mapped by path into +body+ (the
+      # body sent); any other entry is counted as kept, never settled.
+      def with_thinking_drop(response, recovery, body, stripped, transformations, model)
+        if recovery.step == :strip
+          identities = stripped
+          kept = 0
+        else
+          drops = Array(transformations).select { |entry| entry["type"] == "thinking_dropped" }
+          prefix, others = drops.partition { |entry| entry["reason"] == PREFIX_DROP }
+          identities = prefix.filter_map { |entry| identity_at(body, entry["path"]) }.uniq.freeze
+          kept = others.size
+        end
+        fields = { host: @host_name, model: model.to_s, how: recovery.step.to_s, dropped: identities.size,
+                   kept: kept, why: recovery.why }
+        fields[:diagnosis] = recovery.diagnosis if recovery.diagnosis
+        Log.info(:http, "thinking_recovered", **fields)
+        return response if identities.empty?
+
+        response.with(thinking_drop: ThinkingDrop.new(identities: identities, how: recovery.step))
+      end
+
+      def identity_at(body, path)
+        n, m = path.to_s.match(BLOCK_PATH_RE)&.captures&.map(&:to_i)
+        return nil unless n
+
+        block = Array(body[:messages])[n]&.then { |message| Array(message[:content])[m] }
+        thinking_block?(block) ? AnthropicWire.block_identity(block) : nil
+      end
+
+      # The last sentence of a 400 (what it says changed: "The `system`
+      # prompt differs …"), at most 200 characters.
+      def last_sentence(detail)
+        detail.strip.split(/(?<=\.)\s+/).last.to_s[0, 200]
+      end
+
       # What a 400 for +body+ changes (remembered), or nil: the error goes
       # on as it is.
       def refusal_fix(error, body, model)
@@ -309,30 +496,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

@@ -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/memory_bundle/builder.rb

@@ -110,6 +110,8 @@ module Samagotchi
       def select_memories(target_dir, name)
         candidates = Dir.glob(File.join(target_dir, "*.md")).sort
                         .reject { |p| File.basename(p) == "index.md" || File.basename(p).start_with?(".") }
+        symlinks, candidates = candidates.partition { |path| File.symlink?(path) }
+        @warnings.concat(symlinks.map { |path| "#{File.basename(path)} is a symlink (not included)" })
         if candidates.empty?
           raise BuildError, "No memories to build in #{@scope} scope (#{target_dir}): no .md files found"
         end