samagotchi 0.64.0 → 0.65.0

data/lib/samagotchi/llm/errors.rb

@@ -28,7 +28,8 @@ module Samagotchi
     #   OverBudget       402 metadata.reason weight_exceeds_budget: the
     #                    request alone exceeds the key's budget; an
     #                    OutOfCredits, never retried
-    #   ServerError      5xx or a server's error event mid-stream
+    #   ServerError      5xx, or a mid-stream error event with no status or
+    #                    Anthropic error.type
     #   AuthError        401/403, or an API key variable that is not set
     #   BadRequest       other 4xx (a context overflow is one, whatever status;
     #                    so is a model that can't take tools)
@@ -136,11 +137,14 @@ module Samagotchi
       TOOLS_HINT = "this model can't use tools, and chi needs them: pick another model (/model) or host"
 
       # @param hint [String, nil] what to try, added to the summary
-      def initialize(message = nil, context_overflow: false, tools_unsupported: false, reasoning_refused: false, hint: nil,
-                     **)
+      def initialize(message = nil, context_overflow: false, tools_unsupported: false, reasoning_refused: false,
+                     thinking_signature: false, thinking_binding_unsupported: false, sampling_refused: false, hint: nil, **)
+        @sampling_refused = sampling_refused
         @context_overflow = context_overflow
         @tools_unsupported = tools_unsupported
         @reasoning_refused = reasoning_refused
+        @thinking_signature = thinking_signature
+        @thinking_binding_unsupported = thinking_binding_unsupported
         @hint = hint
         super(message, **)
       end
@@ -158,6 +162,24 @@ module Samagotchi
       # be what the host refuses (gpt-oss: "Reasoning is mandatory").
       def reasoning_refused? = @reasoning_refused
 
+      # A 400 about a replayed thinking block's signature (Anthropic: "Invalid
+      # `signature` in `thinking` block", bound to a different conversation
+      # or unreadable). The block is what's wrong, not the thinking fields:
+      # never #reasoning_refused?.
+      def thinking_signature? = @thinking_signature
+
+      # A 400 refusing the thinking binding controls: the
+      # thinking.block_binding field ("Extra inputs are not permitted") or
+      # the thinking-binding-controls beta header. Never #reasoning_refused?.
+      def thinking_binding_unsupported? = @thinking_binding_unsupported
+
+      # A 400 that refuses a sampling field (temperature, top_p, top_k):
+      # Claude's "temperature may only be set to 1 when thinking is
+      # enabled" for the empty-answer retry's temperature. Not
+      # reasoning_refused? although it says "thinking": ChatLoop asks again
+      # without those fields instead.
+      def sampling_refused? = @sampling_refused
+
       def kind = :bad_request
 
       def summary
@@ -277,15 +299,35 @@ module Samagotchi
     # Builds the ProviderError for an HTTP error response or a server's error
     # event.
     module ProviderErrors
-      CONTEXT_OVERFLOW_RE = /exceeds? (the )?(available )?context (size|length|window)|context[_ ]length[_ ]exceeded|exceed_context_size|maximum context length/i
+      # A prompt larger than the model's window; Anthropic: "prompt is too
+      # long: 208310 tokens > 200000 maximum", or "input length and
+      # `max_tokens` exceed context limit: 188240 + 21333 > 200000".
+      CONTEXT_OVERFLOW_RE = Regexp.union(
+        /exceeds? (the )?(available )?context (size|length|window)|context[_ ]length[_ ]exceeded|exceed_context_size/i,
+        /maximum context length|prompt is too long: \d+ tokens/i,
+        /input length and `?max_tokens`? exceed context limit: \d+ \+ \d+ > \d+/i
+      )
       # A model that takes no tools: OpenRouter when no endpoint of the model
       # does ("No endpoints found that support tool use", 404), Ollama ("…
       # does not support tools"), vLLM started without a tool parser.
       TOOLS_UNSUPPORTED_RE = /support tool use|(does not|doesn't) support tools|tool choice requires --enable-auto-tool-choice/i
       # A model or server that can't take images (see VisionUnsupported).
       VISION_UNSUPPORTED_RE = /support image input|image input is not supported|mmproj/i
-      # A 400 about the thinking fields chi sent (Thinking.chat_fields).
+      # A 400 about the thinking fields chi sent (Thinking.chat_fields). Broad;
+      # a signature or binding-control 400 (below) is not one.
       REASONING_REFUSED_RE = /reasoning|thinking/i
+      # Messages' 400 for an assistant turn sent back without its thinking
+      # block before tool_use: about the history sent, not a refusal of
+      # reasoning (it would turn thinking off for the model).
+      THINKING_BLOCK_MISSING_RE = /expected `?thinking`? or `?redacted_thinking`?|must start with a thinking block/i
+      # A 400 about a sampling field (BadRequest#sampling_refused?).
+      SAMPLING_REFUSED_RE = /\b(temperature|top_p|top_k)\b/i
+      # A 400 about a thinking block's signature (BadRequest#thinking_signature?).
+      THINKING_SIGNATURE_RE = /invalid `?signature`? in `?thinking`? block|bound to a different conversation/i
+      # A 400 refusing the binding controls (BadRequest#thinking_binding_unsupported?):
+      # the field without the beta header, or the beta header itself.
+      THINKING_BINDING_UNSUPPORTED_RE = Regexp.union(/block_binding:? extra inputs are not permitted/i,
+                                                     /unexpected value\(s\) `?thinking-binding-controls/i)
       # A 402 about credit held by in-flight requests (see CreditsHeld).
       CREDITS_HELD_RE = /in-flight requests/i
       # A 402's error.metadata.reason when the request can never fit the
@@ -294,6 +336,20 @@ module Samagotchi
       # Seconds to wait before retrying a CreditsHeld without a Retry-After.
       CREDITS_SETTLE_DELAY = 20.0
       RETRYABLE_SERVER_STATUSES = [500, 502, 503, 504, 529].freeze
+      # The HTTP status an Anthropic error.type stands for, for an error
+      # object that carries no numeric code (a Messages stream's error event,
+      # an OpenAI error whose code is null or a name).
+      ERROR_TYPE_STATUS = {
+        "invalid_request_error" => 400, "authentication_error" => 401, "billing_error" => 402,
+        "permission_error" => 403, "not_found_error" => 404, "request_too_large" => 413,
+        "rate_limit_error" => 429, "api_error" => 500, "overloaded_error" => 529, "timeout_error" => 504
+      }.freeze
+      # The HTTP status a Google-style error.code stands for (Fireworks'
+      # errors before a request reaches a model: {"error":{"code":"NOT_FOUND"}}).
+      ERROR_CODE_STATUS = {
+        "INVALID_ARGUMENT" => 400, "UNAUTHENTICATED" => 401, "PERMISSION_DENIED" => 403, "NOT_FOUND" => 404,
+        "RESOURCE_EXHAUSTED" => 429
+      }.freeze
 
       module_function
 
@@ -322,10 +378,7 @@ module Samagotchi
           else
             OutOfCredits.new(text, **options)
           end
-        when 400..499
-          tools = TOOLS_UNSUPPORTED_RE.match?(message)
-          BadRequest.new(text, tools_unsupported: tools,
-                               reasoning_refused: status == 400 && !tools && REASONING_REFUSED_RE.match?(message), **options)
+        when 400..499 then bad_request(text, status, message, options)
         when 500..599
           ServerError.new(text, retryable: RETRYABLE_SERVER_STATUSES.include?(status),
                                 retry_after: parse_retry_after(retry_after), **options)
@@ -359,15 +412,31 @@ module Samagotchi
         from_error_json(body.to_s, host: host)
       end
 
+      # A BadRequest for a 4xx, with its predicates from +message+.
+      def bad_request(text, status, message, options)
+        tools = TOOLS_UNSUPPORTED_RE.match?(message)
+        signature = THINKING_SIGNATURE_RE.match?(message)
+        binding = !signature && THINKING_BINDING_UNSUPPORTED_RE.match?(message)
+        sampling = status == 400 && !tools && !signature && !binding && SAMPLING_REFUSED_RE.match?(message)
+        missing = THINKING_BLOCK_MISSING_RE.match?(message)
+        refused = status == 400 && !tools && !signature && !binding && !sampling && !missing &&
+                  REASONING_REFUSED_RE.match?(message)
+        BadRequest.new(text, tools_unsupported: tools, thinking_signature: signature, thinking_binding_unsupported: binding,
+                             sampling_refused: sampling, reasoning_refused: refused, **options)
+      end
+
       # The ProviderError for a JSON error object, by its error.code (an HTTP
-      # status); 500 when it has none.
+      # status, or a name in ERROR_CODE_STATUS), else by its error.type
+      # (ERROR_TYPE_STATUS); 500 when it has neither.
       def from_error_json(raw, host:)
         parsed = parse_json(raw)
         error = parsed.is_a?(Hash) && parsed["error"].is_a?(Hash) ? parsed["error"] : parsed
         code = error.is_a?(Hash) ? error["code"] : nil
         code = code.to_i if code.is_a?(String) && code.match?(/\A\d{3}\z/)
-        status = code.is_a?(Integer) && code.between?(400, 599) ? code : 500
-        from_response(status: status, body: raw, host: host)
+        status = code if code.is_a?(Integer) && code.between?(400, 599)
+        status ||= ERROR_CODE_STATUS[code] if code.is_a?(String)
+        status ||= ERROR_TYPE_STATUS[error["type"]] if error.is_a?(Hash)
+        from_response(status: status || 500, body: raw, host: host)
       end
 
       # The human part of an error body: error.message, message, error (a

data/lib/samagotchi/llm/model_listing.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module LLM
+    # A model a host lists. Unknown fields are nil.
+    ModelInfo = Data.define(:id, :context_window, :supports_tools, :raw) do
+      # true when the list says the model takes images, false when it says
+      # it doesn't, else nil: OpenRouter's architecture.input_modalities,
+      # Anthropic's capabilities.image_input.supported, Splash's top-level
+      # input_modalities or vision, Fireworks' supports_image_input,
+      # llama.cpp's "multimodal" capability.
+      def image_input
+        return nil unless raw.is_a?(Hash)
+
+        modalities = raw.dig("architecture", "input_modalities")
+        return modalities.include?("image") if modalities.is_a?(Array)
+
+        capabilities = raw["capabilities"]
+        supported = capabilities.dig("image_input", "supported") if capabilities.is_a?(Hash)
+        return supported if [true, false].include?(supported)
+        return raw["input_modalities"].include?("image") if raw["input_modalities"].is_a?(Array)
+        return raw["vision"] if [true, false].include?(raw["vision"])
+        return raw["supports_image_input"] if [true, false].include?(raw["supports_image_input"])
+        return true if capabilities.is_a?(Array) && capabilities.include?("multimodal")
+
+        nil
+      end
+    end
+
+    # A chat adapter's model list, kept per models_ttl: what #context_window
+    # and #image_input read. The adapter defines #list_models (its wire's
+    # GET) and calls #init_model_listing from its initializer.
+    module ModelListing
+      # The window (tokens) the host lists for +model+, or nil. The list is
+      # read once per models_ttl; a failed listing answers nil.
+      def context_window(model:)
+        listed_model(model)&.context_window
+      rescue StandardError
+        nil
+      end
+
+      # Whether the host's list says +model+ takes images (ModelInfo#image_input),
+      # or nil when it doesn't say or the listing fails.
+      def image_input(model:)
+        listed_model(model)&.image_input
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def init_model_listing(models_ttl)
+        @models_ttl = models_ttl
+        @models_mutex = Mutex.new
+      end
+
+      # +model+'s entry in the cached list: its exact id, else any case.
+      def listed_model(model)
+        cached_models.find { |m| m.id == model.to_s } || cached_models.find { |m| m.id.casecmp?(model.to_s) }
+      end
+
+      def model_entries(body)
+        return [] unless body.is_a?(Hash)
+
+        entries = body["data"].is_a?(Array) ? body["data"] : body["models"]
+        Array(entries).select { |entry| entry.is_a?(Hash) }
+      end
+
+      def model_info(raw)
+        id = (raw["id"] || raw["model"] || raw["name"]).to_s
+        ModelInfo.new(id: id, context_window: window_of(raw), supports_tools: tools_support(raw), raw: raw)
+      end
+
+      # The running window when the list says: context_length, context_window,
+      # max_model_len, or llama.cpp's meta.n_ctx (not n_ctx_train).
+      def window_of(raw)
+        [raw["context_length"], raw["context_window"], raw["max_model_len"], raw.dig("meta", "n_ctx")].each do |value|
+          return value if value.is_a?(Integer) && value.positive?
+        end
+        nil
+      end
+
+      # Whether the list says the model takes tools: OpenRouter's
+      # supported_parameters or llama.cpp's capabilities naming "tools"
+      # (true, else nil), or Fireworks' supports_tools (true or false).
+      def tools_support(raw)
+        return raw["supports_tools"] if [true, false].include?(raw["supports_tools"])
+
+        listed = raw["supported_parameters"] || raw["capabilities"]
+        return nil unless listed.is_a?(Array)
+
+        listed.include?("tools") || nil
+      end
+
+      def cached_models
+        @models_mutex.synchronize do
+          fresh = @models_at && (monotonic - @models_at) < @models_ttl
+          return @models if fresh
+        end
+        models = list_models
+        @models_mutex.synchronize do
+          @models = models
+          @models_at = monotonic
+        end
+        models
+      end
+
+      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/samagotchi/llm/model_result.rb

@@ -15,17 +15,24 @@ module Samagotchi
     # conversation) and .empty_retries (the retries spent): the Engine saves
     # them on the turn's note for the UIs (TurnNote.empty).
     #
+    # .refusal is set when the provider refused the answer (Messages'
+    # stop_reason refusal, OpenAI's content_filter): {category:} as the
+    # provider names it, {} without one; nil otherwise. Such a turn is an
+    # empty answer the loop never asked again.
+    #
     # .run_start is where the turn's run started in the conversation (the
     # length of the messages the loop got), set by the Engine after the loop
     # returns; nil from a loop called directly. A step-limit offer keeps it
     # (TurnFlow), so a Continue resumes that run (Engine#run_turn resume_from:).
     class ModelResult
       attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
-                  :tool_activity, :context_status, :pending_tool_calls, :empty_steps, :empty_retries
+                  :tool_activity, :context_status, :pending_tool_calls, :empty_steps, :empty_retries, :refusal
       attr_accessor :run_start
 
       def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
-                     tool_activity: [], context_status: nil, pending_tool_calls: false, empty_steps: [], empty_retries: 0)
+                     tool_activity: [], context_status: nil, pending_tool_calls: false, empty_steps: [], empty_retries: 0,
+                     refusal: nil)
+        @refusal = refusal
         @empty_steps = Array(empty_steps)
         @empty_retries = empty_retries.to_i
         @text = text

data/lib/samagotchi/llm/openai_chat.rb

@@ -4,30 +4,16 @@ require "json"
 require "uri"
 require_relative "../config"
 require_relative "../sampling_settings"
+require_relative "../thinking"
 require_relative "errors"
 require_relative "http"
+require_relative "model_listing"
 require_relative "prompt_cache"
 require_relative "usage"
 require_relative "utf8_scrub"
 
 module Samagotchi
   module LLM
-    # A model a host lists. Unknown fields are nil.
-    ModelInfo = Data.define(:id, :context_window, :supports_tools, :raw) do
-      # true when the list says the model takes images (OpenRouter's
-      # architecture.input_modalities, llama.cpp's "multimodal" capability),
-      # false when it lists input modalities without "image", else nil.
-      def image_input
-        return nil unless raw.is_a?(Hash)
-
-        modalities = raw.dig("architecture", "input_modalities")
-        return modalities.include?("image") if modalities.is_a?(Array)
-        return true if Array(raw["capabilities"]).include?("multimodal")
-
-        nil
-      end
-    end
-
     # A tool call the model made. arguments: the parsed Hash, or the raw
     # String when it isn't valid JSON (the tool then reports the error).
     ToolCall = Data.define(:id, :name, :arguments)
@@ -43,9 +29,17 @@ module Samagotchi
     # +top_logprobs+: the first answer token's likeliest alternatives
     # (TokenLogprob) when the request asked for logprobs and the server
     # sent them (a non-streamed answer only); [] otherwise.
+    # +provider_content+: the response's content blocks in order, as the
+    # server sent them (string keys), for a wire that sends them back
+    # verbatim (AnthropicMessages: thinking blocks with their signatures);
+    # nil on the OpenAI wire.
+    # +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.
     ChatResponse = Data.define(:text, :reasoning, :tool_calls, :usage, :finish_reason, :model, :provider, :cut,
-                               :top_logprobs) do
-      def initialize(model: nil, provider: nil, cut: nil, top_logprobs: [].freeze, **fields) = super
+                               :top_logprobs, :provider_content, :stop_details) do
+      def initialize(model: nil, provider: nil, cut: nil, top_logprobs: [].freeze, provider_content: nil, stop_details: nil,
+                     **fields) = super
     end
 
     # One alternative for an answer token: its text and log probability.
@@ -75,6 +69,8 @@ module Samagotchi
     # default, with errors mapped to ProviderError. It speaks the wire format
     # only; the chat loop owns the conversation and the tools.
     class OpenAIChat
+      include ModelListing
+
       MAX_MODEL_PAGES = 20
       # How much of a 200's non-stream body is read as a possible JSON error.
       PLAIN_ERROR_LIMIT = 64 * 1024
@@ -90,14 +86,11 @@ module Samagotchi
 
       # @param entry [HostRegistry::HostEntry]
       def self.for(entry, **)
-        new(base_url: entry.openai_base_url, host_name: entry.name, api_key_env: entry.api_key_env,
-            remote: entry.remote?, default_max_tokens: (OPENROUTER_MAX_TOKENS if openrouter?(entry.openai_base_url)),
+        new(base_url: entry.api_base_url, host_name: entry.name, api_key_env: entry.api_key_env, auth: entry.auth,
+            remote: entry.remote?, default_max_tokens: (OPENROUTER_MAX_TOKENS if openrouter?(entry.api_base_url)),
             **)
       end
 
-      # true when a streamed +payload+ carries a tool-call delta.
-      def self.tool_call_delta?(payload) = Assembly.tool_call_delta?(payload)
-
       # true when +url+ is OpenRouter's API (openrouter.ai or a subdomain).
       def self.openrouter?(url)
         host = URI(url.to_s).host.to_s.downcase
@@ -134,19 +127,23 @@ module Samagotchi
       # @param host_name [String] names the host in errors
       # @param api_key_env [String, nil] the variable holding the API key;
       #   nil sends no Authorization header (a local server)
+      # @param auth [Symbol, nil] the header the key goes in
+      #   (ApiKey::SCHEMES); nil: Authorization: Bearer
       # @param stream [Boolean] stream the reply (false: one JSON body)
       # @param retries [Boolean] false: one attempt
       # @param timeout [Numeric, nil] read timeout in seconds (default
       #   server.read_timeout); the connect timeout is capped by it
+      # @param open_timeout [Numeric, nil] connect timeout in seconds, when
+      #   shorter than that (a reachability probe's)
       # @param models_ttl [Numeric] how long #context_window reuses the list
       # @param remote [Boolean] a provider on the network, not a local server
       # @param first_token_timeout [Numeric, nil] seconds a streamed answer
       #   may take to show something (LLM::HTTP); nil: no limit
       # @param default_max_tokens [Integer, nil] max_tokens for a request
       #   whose options name none (OPENROUTER_MAX_TOKENS); nil sends none
-      def initialize(base_url:, host_name:, api_key_env: nil, stream: true, retries: true, timeout: nil,
+      def initialize(base_url:, host_name:, api_key_env: nil, auth: nil, stream: true, retries: true, timeout: nil,
                      env: ENV, sleeper: nil, retry_policy: nil, models_ttl: DEFAULT_MODELS_TTL, remote: false,
-                     first_token_timeout: nil, purpose: "chat", default_max_tokens: nil)
+                     first_token_timeout: nil, purpose: "chat", default_max_tokens: nil, open_timeout: nil)
         @remote = remote
         @default_max_tokens = default_max_tokens
         # What its requests are for, in the log (LLM::HTTP::LOGGED_PURPOSES).
@@ -156,13 +153,12 @@ module Samagotchi
         @host_name = host_name.to_s
         @api_key_env = api_key_env
         @stream = stream
-        @models_ttl = models_ttl
-        @models_mutex = Mutex.new
-        open_timeout, read_timeout = timeouts(timeout)
+        init_model_listing(models_ttl)
+        open_timeout, read_timeout = timeouts(timeout, open_timeout)
         policy = retry_policy || (retries ? nil : HTTP::RetryPolicy.none)
         @http = HTTP.new(label: @host_name, open_timeout: open_timeout, read_timeout: read_timeout,
                          retry_policy: policy, sleeper: sleeper, first_token_timeout: first_token_timeout,
-                         api_key: ApiKey.for(api_key_env, host: @host_name, env: env))
+                         api_key: ApiKey.for(api_key_env, host: @host_name, env: env, scheme: auth))
       end
 
       # @param messages [Array<Hash>] wire messages (role, content, tool_calls,
@@ -216,6 +212,25 @@ module Samagotchi
       # A provider on the network: no llama.cpp /props to ask for the window.
       def remote? = @remote
 
+      # Model entries go back as text, tool_calls and reasoning_content,
+      # never as saved provider blocks (AnthropicMessages does).
+      def replays_content? = false
+
+      # true when a streamed chunk's +payload+ (as #chat's on_delta gets it)
+      # carries part of a tool call (ChatLoop marks the chunk's event).
+      def tool_call_delta?(payload) = Assembly.tool_call_delta?(payload)
+
+      # The request fields a thinking +level+ (Thinking::LEVELS) adds on
+      # this wire: Thinking.chat_fields's OpenAI-style switches.
+      # @return [Hash] frozen
+      def thinking_fields(level) = Thinking.chat_fields(level)
+
+      # The thinking fields for a short side answer from a model that
+      # refused thinking off (gpt-oss: "Reasoning is mandatory"): none, the
+      # model's own default.
+      # @return [Hash] frozen
+      def thinking_off_refused_fields = {}.freeze
+
       # @return [Array<ModelInfo>] the host's models (every page)
       def list_models
         models = []
@@ -231,26 +246,6 @@ module Samagotchi
         models
       end
 
-      # The window (tokens) the host lists for +model+, or nil. The list is
-      # read once per models_ttl; a failed listing answers nil.
-      def context_window(model:)
-        info = cached_models.find { |m| m.id == model.to_s } ||
-               cached_models.find { |m| m.id.casecmp?(model.to_s) }
-        info&.context_window
-      rescue StandardError
-        nil
-      end
-
-      # Whether the host's list says +model+ takes images (ModelInfo#image_input),
-      # or nil when it doesn't say or the listing fails.
-      def image_input(model:)
-        info = cached_models.find { |m| m.id == model.to_s } ||
-               cached_models.find { |m| m.id.casecmp?(model.to_s) }
-        info&.image_input
-      rescue StandardError
-        nil
-      end
-
       def self.served_model(payload)
         model = payload.is_a?(Hash) ? payload["model"] : nil
         model.is_a?(String) && !model.strip.empty? ? model : nil
@@ -265,9 +260,10 @@ module Samagotchi
 
       private
 
-      def timeouts(timeout)
+      def timeouts(timeout, open_limit = nil)
         open_timeout = Samagotchi::Config.positive_seconds("server.open_timeout")
         read_timeout = Samagotchi::Config.positive_seconds("server.read_timeout")
+        open_timeout = [open_timeout, open_limit].min if open_limit
         return [open_timeout, read_timeout] unless timeout
 
         [[open_timeout, timeout].min, timeout]
@@ -411,49 +407,6 @@ module Samagotchi
 
       def get_request(uri) = Net::HTTP::Get.new(uri)
 
-      def model_entries(body)
-        return [] unless body.is_a?(Hash)
-
-        entries = body["data"].is_a?(Array) ? body["data"] : body["models"]
-        Array(entries).select { |entry| entry.is_a?(Hash) }
-      end
-
-      def model_info(raw)
-        id = (raw["id"] || raw["model"] || raw["name"]).to_s
-        ModelInfo.new(id: id, context_window: window_of(raw), supports_tools: tools_support(raw), raw: raw)
-      end
-
-      # The running window when the list says: context_length, context_window,
-      # max_model_len, or llama.cpp's meta.n_ctx (not n_ctx_train).
-      def window_of(raw)
-        [raw["context_length"], raw["context_window"], raw["max_model_len"], raw.dig("meta", "n_ctx")].each do |value|
-          return value if value.is_a?(Integer) && value.positive?
-        end
-        nil
-      end
-
-      def tools_support(raw)
-        listed = raw["supported_parameters"] || raw["capabilities"]
-        return nil unless listed.is_a?(Array)
-
-        listed.include?("tools") || nil
-      end
-
-      def cached_models
-        @models_mutex.synchronize do
-          fresh = @models_at && (monotonic - @models_at) < @models_ttl
-          return @models if fresh
-        end
-        models = list_models
-        @models_mutex.synchronize do
-          @models = models
-          @models_at = monotonic
-        end
-        models
-      end
-
-      def monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
       # Streamed deltas put together: text, reasoning, tool calls by index,
       # the finish reason, the usage chunk, the served model and provider.
       class Assembly

data/lib/samagotchi/model_profile.rb

@@ -484,7 +484,7 @@ module Samagotchi
     private_class_method :configured
 
     # Only a native llama.cpp host has /props with a chat template; a chat
-    # host (api: openai) barely uses a profile, and mlx/oMLX expose none.
+    # host (api: openai or anthropic) barely uses a profile, and mlx/oMLX expose none.
     def self.probe?(entry, client)
       return false if client.nil? || !client.respond_to?(:server_props)
       return false if entry&.chat?

data/lib/samagotchi/reasoning_history.rb

@@ -16,12 +16,17 @@ module Samagotchi
   #
   # Order (#resolve): the session's own level (/reasoning-history), then
   # SAMAGOTCHI_REASONING_HISTORY, models.<key>.reasoning_history,
-  # hosts.<name>.reasoning_history, then turn. Native hosts ignore it:
+  # hosts.<name>.reasoning_history, then the host's api default: all for
+  # api: anthropic (its thinking blocks go back verbatim, and removing
+  # earlier turns' would rewrite the cached prefix every turn; ChatLoop
+  # floors drop at turn there), turn elsewhere. Native hosts ignore it:
   # KernelLoop keeps the running turn's reasoning on its own, from the
   # run's start (.run_start).
   module ReasoningHistory
     LEVELS = %i[drop turn all].freeze
     DEFAULT = :turn
+    # The default for a host's api when it isn't DEFAULT.
+    API_DEFAULTS = { anthropic: :all }.freeze
     KEY = "reasoning_history"
     ENV_NAME = "SAMAGOTCHI_REASONING_HISTORY"
     # The source a session's own level reads as.
@@ -82,7 +87,7 @@ module Samagotchi
       host = target.entry&.reasoning_history
       return [host, "hosts.#{target.entry.name}"] if host
 
-      [DEFAULT, nil]
+      [API_DEFAULTS.fetch(target.entry&.api&.to_sym, DEFAULT), nil]
     end
 
     # #resolve, as a SettingExplained with the session's own level beside it.
@@ -112,10 +117,15 @@ module Samagotchi
     end
 
     # Whether +conversation+ has a model entry with thinking (what all
-    # sends back as reasoning_content; LLM::ChatLoop#thought?).
+    # sends back as reasoning_content; LLM::ChatLoop#thought?), or with a
+    # saved thinking block (a Messages host's, which may carry no text:
+    # Claude's omitted display).
     def earlier_thought?(conversation)
       Array(conversation).any? do |entry|
-        entry[:role].to_s == "model" && entry[:thinking].is_a?(String) && !entry[:thinking].strip.empty?
+        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) }
       end
     end
 

data/lib/samagotchi/recap_setup.rb

@@ -65,7 +65,8 @@ module Samagotchi
         min_user_turns: recap_number_setting(kwarg_config, :min_user_turns, "recap.min_user_turns", IdleRecap::DEFAULT_MIN_USER_TURNS, :int),
         timeout: recap_number_setting(kwarg_config, :timeout, "recap.timeout", IdleRecap::DEFAULT_TIMEOUT_SECONDS, :float),
         sentences: recap_sentences(string_config(kwarg_config, :sentences) || registry_string("recap.sentences")),
-        store: RecapStore.new(session_id_lookup: -> { session_id.call }, state_dir_lookup: -> { state_dir.call })
+        store: RecapStore.new(session_id_lookup: -> { session_id.call }, state_dir_lookup: -> { state_dir.call }),
+        session_id: -> { session_id.call }
       )
     end