samagotchi 0.64.0 → 0.66.0

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/plugin/api.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../toolkit"
 require_relative "../log"
 require_relative "../hooks/registry"
 require_relative "../tools/args"
+require_relative "../commands/registry"
 require_relative "service"
 require_relative "tool_result"
 
@@ -16,6 +18,8 @@ module Samagotchi
       COMMAND_NAME = %r{\A/[a-z][a-z0-9_-]{0,31}\z}
       TOOL_NAME = /\A[a-z][a-z0-9_]{0,47}\z/
       PARAM_NAME = /\A[a-z_][a-z0-9_]*\z/i
+      ANNOTATION_LABEL_MAX = 40
+      ANNOTATIONS_MAX = 5
 
       # @param bundle [String]
       # @param label [String] "<file> (bundle <name>)": what hooks and
@@ -29,9 +33,11 @@ module Samagotchi
         @context = context
         @hooks = []
         @commands = []
+        @annotations = []
         @tools = []
         @services = []
         @inits = []
+        @toolkits = []
         @committed = false
       end
 
@@ -63,6 +69,35 @@ module Samagotchi
         nil
       end
 
+      # A pill in the web's selection bar: it prepares +command+ (a command
+      # line) with +template+ filled from the selected text on the lines
+      # under it ({quote}: the labelled quote block Annotate makes, {text}:
+      # the selection alone, {source}: answer, thinking, step, tool or
+      # user), and fills the composer with it, or sends it at once with
+      # +send+ (docs/plugins.md). Web only.
+      # @param label [String] the pill's text, 1–40 characters
+      # @param command [String] "/name" or "/name words": a command this
+      #   plugin registers (checked once #register returns, so the order
+      #   doesn't matter; another's is a load error)
+      # @param template [String] what goes under the command line
+      # @param send [Boolean] send at once instead of filling the composer
+      def annotation(label, command:, template: "{quote}", send: false)
+        label = label.to_s.strip
+        unless label.length.between?(1, ANNOTATION_LABEL_MAX)
+          raise ArgumentError, "annotation label #{label.inspect} must be 1 to #{ANNOTATION_LABEL_MAX} characters"
+        end
+
+        line = command.to_s.strip
+        name = line.split(/\s/, 2).first.to_s
+        raise ArgumentError, "annotation #{label}: command #{line.inspect} must start with a /name" unless name.match?(COMMAND_NAME)
+        raise ArgumentError, "annotation #{label}: template must be a non-blank String" unless template.is_a?(String) && !template.strip.empty?
+        raise ArgumentError, "at most #{ANNOTATIONS_MAX} annotations per plugin" if @annotations.size >= ANNOTATIONS_MAX
+
+        @annotations << { name: name, annotation: Commands::Registry::Annotation.new(label: label, line: line, template: template,
+                                                                                     sends: send ? true : false) }
+        nil
+      end
+
       # A tool the model can call: the block gets the call's arguments (a
       # frozen Hash, string keys, typed by the schema: see Tools::Args) and
       # the Context, and returns the result text ("Error: …" marks a
@@ -215,12 +250,40 @@ module Samagotchi
         nil
       end
 
-      # Register what was staged. Called by Loader after #register.
+      TOOLKIT_NAME = /\A[a-z][a-z0-9_-]{0,31}\z/
+
+      # A named toolkit sessions can be put on (/toolkit NAME, chi --toolkit,
+      # toolkit.default, ctx.use_toolkit): +base+'s tools (a toolkit chi or
+      # a bundle has) with +add+ declared and +remove+ left out. A name chi
+      # (full, lean, child) or another bundle has is a load error; a base
+      # that doesn't resolve leaves the sessions on it with every tool
+      # (Toolkit#resolve).
+      def toolkit(name, base:, add: [], remove: [])
+        name = name.to_s
+        raise ArgumentError, "toolkit name #{name.inspect} must be a-z, 0-9, _ and -" unless name.match?(TOOLKIT_NAME)
+        raise ArgumentError, "this chi has no toolkits (plugins: false)" unless @registries.toolkits
+        if Toolkit::BUILTIN_KITS.key?(name)
+          raise ArgumentError, "toolkit #{name} is chi's own"
+        elsif (taken = @registries.toolkits.find { |kit| kit.name == name })
+          raise ArgumentError, "toolkit #{name} is already declared (#{taken.source})"
+        end
+        raise ArgumentError, "toolkit #{name} is declared twice" if @toolkits.any? { |kit| kit.name == name }
+
+        @toolkits << Toolkit::Kit.new(name: name, base: base, add: add, remove: remove, source: @bundle)
+        nil
+      end
+
+      # Register what was staged. Called by Loader after #register. What
+      # can only be checked now (an annotation's command) is checked before
+      # anything is registered: a raise here leaves the registries as they were.
       def commit!
+        check_annotations!
         context = @context
         @commands.each do |cmd|
           block = cmd[:block]
-          @registries.commands.register(cmd[:name], cmd[:description], anytime: cmd[:anytime], source: @bundle) do |args|
+          annotations = @annotations.select { |item| item[:name] == cmd[:name] }.map { |item| item[:annotation] }
+          @registries.commands.register(cmd[:name], cmd[:description], anytime: cmd[:anytime], source: @bundle,
+                                                                       annotations: annotations) do |args|
             block.call(args, context)
           end
         end
@@ -243,12 +306,24 @@ module Samagotchi
             block.call(context)
           end
         end
+        @registries.toolkits&.concat(@toolkits)
         @committed = true
       end
 
       # @return [Hash] how many of each it registered (for the log)
-      def counts = { commands: @commands.size, tools: @tools.size, hooks: @hooks.size, services: @services.size,
-                     inits: @inits.size }
+      def counts = { commands: @commands.size, annotations: @annotations.size, tools: @tools.size, hooks: @hooks.size,
+                     services: @services.size, inits: @inits.size, toolkits: @toolkits.size }
+
+      # Each annotation's command is one #command staged.
+      def check_annotations!
+        names = @commands.map { |cmd| cmd[:name] }
+        @annotations.each do |item|
+          next if names.include?(item[:name])
+
+          raise ArgumentError, "annotation #{item[:annotation].label}: #{item[:name]} is not a command this plugin registers"
+        end
+      end
+      private :check_annotations!
 
       # A checked tool declaration (#tool's arguments: Api#tool and
       # ToolSet#tool pass theirs on, so a new keyword is added here).
@@ -281,9 +356,7 @@ module Samagotchi
       def self.apply_tools(registry, bundle, specs, context)
         wanted = specs.to_h { |spec| [spec[:name], spec] }
         changed = false
-        registry.entries.each do |entry|
-          next unless entry.source == bundle
-
+        registry.by_source(bundle).each do |entry|
           if (spec = wanted[entry.name]) && spec[:schema] == entry.schema && spec[:label] == entry.label
             entry_fields(spec, context).slice(:handler, :preview, :targets, :refs).each { |key, value| entry[key] = value }
             next

data/lib/samagotchi/plugin/context.rb

@@ -29,9 +29,13 @@ module Samagotchi
     # (reason, label), each true when it acted on a running turn.
     # +frontend+ returns the Engine's interface (:repl, :worker,
     # :non_interactive), which ctx.frontend names for plugins.
+    # +toolkit+ returns the session's toolkit name, +declared_tools+ the
+    # tool names its next turn declares, +use_toolkit+ takes a name and
+    # returns whether it staged it (Engine#use_toolkit).
     Host = Struct.new(:session_id, :cwd, :messages, :messages_partial, :notify, :ask_user, :cancelled, :card,
                       :ask_model, :model_name, :model_key, :state_dir, :scratch, :setup, :prompt_files,
-                      :steer, :stop_turn, :stop_generation, :frontend, keyword_init: true)
+                      :steer, :stop_turn, :stop_generation, :frontend, :toolkit, :declared_tools, :use_toolkit,
+                      keyword_init: true)
 
     # ctx.ask_model failed: the model couldn't be reached, timed out, or
     # sent nothing usable. The message says why, for the user.
@@ -109,6 +113,23 @@ module Samagotchi
       #   current_model_only names it
       def model_key = @host.model_key&.call
 
+      # @return [String, nil] the name of the session's toolkit ("full" for
+      #   one from before toolkits; nil with no session)
+      def toolkit = @host.toolkit&.call
+
+      # @return [Array<String>] the tools the session's next turn declares
+      #   (its toolkit resolved: a kit name says less than this)
+      def declared_tools = Array(@host.declared_tools&.call)
+
+      # Put the session on toolkit +name+ (a plugin's chi.toolkit, or
+      # chi's): only before the session's first model reply and never while
+      # a turn runs, since the declared tools start every request; it then
+      # applies at the next turn's start, and the user is told. Otherwise
+      # nothing changes and the plugin can say to run /toolkit NAME.
+      # @return [Boolean] whether it was staged
+      # @raise [ArgumentError] a toolkit no one declared
+      def use_toolkit(name) = !!@host.use_toolkit&.call(name.to_s)
+
       # Whether the session is a `chi scratch` one (deleted when it ends).
       def scratch? = !!@host.scratch&.call
 

data/lib/samagotchi/plugin/loader.rb

@@ -16,9 +16,10 @@ module Samagotchi
     # (the Engine's system prompts); +services+ (Plugin::Services) is what
     # Engine#shutdown stops; +stage_tools+ is (bundle, specs, context),
     # chi.replace_tools' set, which the Engine applies on its turn thread;
-    # +init+ adds a chi.init task (Engine#add_init_task).
+    # +init+ adds a chi.init task (Engine#add_init_task); +toolkits+ is the
+    # Engine's list of the plugins' toolkits (chi.toolkit: Toolkit::Kit).
     Registries = Struct.new(:commands, :tools, :hooks, :context_for, :tools_changed, :services, :stage_tools, :init,
-                            keyword_init: true)
+                            :toolkits, keyword_init: true)
 
     # Loads installed bundles' plugins (manifest plugin: {file:, sha256:})
     # into an Engine's registries (docs/plugins.md).

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
 

data/lib/samagotchi/self_report.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
 require_relative "version"
 require_relative "config"
 require_relative "context_window"
@@ -16,8 +13,7 @@ require_relative "thinking"
 require_relative "reasoning_history"
 require_relative "served_model"
 require_relative "host_registry"
-require_relative "llm/http"
-require_relative "llm/api_key"
+require_relative "llm/adapters"
 require_relative "tools/memory"
 require_relative "hooks/loader"
 require_relative "memory_bundle/provenance"
@@ -273,7 +269,9 @@ module Samagotchi
       entry = HostRegistry.new(env: env).resolve(model).entry
       return "-" unless entry
 
-      entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
+      return "native (raw prompt)" unless entry.chat?
+
+      entry.dialect ? "chat (api: #{entry.api}, dialect: #{entry.dialect})" : "chat (api: #{entry.api})"
     end
 
     NO_PROPS = "reported per turn (the server has no /props)"
@@ -281,7 +279,7 @@ module Samagotchi
     # chi self's one server call: a single-model llama.cpp answers any name
     # with the model it loaded, and its /props names it (model_alias). One
     # GET with the probe's short timeouts; a remote host isn't asked. A local
-    # chat host (api: openai) has no /props, so it gets a GET <base>/models
+    # chat host (api: openai or anthropic) has no /props, so it gets its model list
     # with the same timeouts: up/down and the ids it serves.
     def served_model_for(model, env)
       registry = HostRegistry.new(env: env)
@@ -306,36 +304,28 @@ module Samagotchi
       "unknown (#{e.class})"
     end
 
-    # A local chat host's reachability: one GET <base>/models with the
-    # native probe's short timeouts (Client's /props probe), no retry. Up
-    # with the ids it serves, down when it doesn't answer.
+    # A local chat host's reachability: its model list through its own
+    # adapter (LLM::Adapters, not the registry's cached one) with the native
+    # probe's short timeouts (Client's /props probe), no retry. Up with the
+    # ids it serves, down when it doesn't answer.
     def chat_served_model_for(entry, bare, env)
-      uri = URI("#{entry.openai_base_url}/models")
-      request = Net::HTTP::Get.new(uri)
-      http = LLM::HTTP.new(label: entry.name, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
-                           read_timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT,
-                           retry_policy: LLM::HTTP::RetryPolicy.none,
-                           api_key: LLM::ApiKey.for(entry.api_key_env, host: entry.host, env: env))
-      response = http.fetch(uri, request, retries: false, check_status: false, log_fields: { purpose: "models" })
-      return "down (HTTP #{response.code})" unless response.code.to_s == "200"
-
-      ids = chat_model_ids(response.body)
+      adapter = LLM::Adapters.for(entry, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
+                                         timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT, retries: false, env: env)
+      ids = adapter.list_models.map(&:id).reject(&:empty?)
       return "up (no models listed)" if ids.empty?
 
       note = ids.any? { |id| id.casecmp?(bare.to_s) } ? "" : " (not #{bare})"
       "up: #{ids.join(", ")}#{note}"
+    rescue LLM::ProviderError => e
+      # A status (an error, or a 3xx such as a proxy's login page) is down;
+      # a 200 whose body isn't a model list (ProtocolError) is up.
+      return "down (HTTP #{e.status})" if e.status
+
+      e.is_a?(LLM::ProtocolError) ? "up (no models listed)" : "down (the server didn't answer; is it running?)"
     rescue StandardError
       "down (the server didn't answer; is it running?)"
     end
 
-    def chat_model_ids(body)
-      parsed = JSON.parse(body.to_s)
-      data = parsed.is_a?(Hash) ? parsed["data"] : parsed
-      Array(data).filter_map { |raw| raw.is_a?(Hash) ? (raw["id"] || raw[:id]).to_s : raw.to_s }.reject(&:empty?)
-    rescue JSON::ParserError
-      []
-    end
-
     # Offline, so no /props probe: where nothing is configured, a native
     # llama.cpp host's chat template decides at runtime.
     def profile_for(model, env)