samagotchi 0.64.0 → 0.65.0

data/lib/samagotchi/engine.rb

@@ -224,6 +224,7 @@ module Samagotchi
       # and after a reminder turn), so the idle layer's clock is identical
       # across UIs.
       @turn_state.restart_clock!
+      @side_client_mutex = Mutex.new
       @recap = RecapSetup.build(recap, engine: self, host_registry: @host_registry,
                                 session_target: -> { session_model_recap_target },
                                 session_id: -> { @session&.id }, state_dir: -> { session_state_dir })
@@ -299,7 +300,7 @@ module Samagotchi
       # event[:ask_user], event[:stop_turn]): the Engine's routes to the UIs.
       @hooks.runtime = hook_runtime
       # The loop follows the effective model's host (its api:): the raw-prompt
-      # NativeBackend, or the chat backend for openai hosts.
+      # NativeBackend, or the chat backend for chat hosts (openai, anthropic).
       @native_backend = LLM::NativeBackend.new(kernel: @kernel)
     end
     private :wire_kernel
@@ -405,6 +406,10 @@ module Samagotchi
     # for #cut_for_steer.
     def input_epoch = @steer_cut.input_epoch
 
+    # The running generation's phase (SteerCut#generation_snapshot): what
+    # Bridge#snapshot puts in current_turn.generation.
+    def generation_snapshot = @steer_cut.generation_snapshot
+
     # Like #steer, for the turn that begins next (a continue turn answered
     # with a text): it joins that turn at its first boundary. Callable from
     # any thread; a turn that never begins keeps it for the next one, unless
@@ -1082,7 +1087,7 @@ module Samagotchi
       @last_context_status = saved_context_status(@metrics.snapshot[:context]) || @last_context_status if @last_context_status
     end
 
-    # The effective model is on a chat host (api: openai), whose loop uses
+    # The effective model is on a chat host (api: openai or anthropic), whose loop uses
     # no prompt profile.
     def chat_model? = @host_registry.resolve(@effective_model_name).entry.chat?
 
@@ -2285,7 +2290,7 @@ module Samagotchi
       # A retry's nudge at the tail goes: this note says it all. An earlier
       # turn's note stays: it says why that turn ended.
       if result.empty_answer?
-        note = TurnNote.empty(retries: result.empty_retries, steps: result.empty_steps)
+        note = TurnNote.empty(retries: result.empty_retries, steps: result.empty_steps, refusal: result.refusal)
         conversation&.replace(TurnNote.without_trailing_nudge(conversation))
         saved = TurnNote.without_trailing_nudge(conversation || turn.session.messages)
         conversation << note if conversation
@@ -2482,6 +2487,15 @@ module Samagotchi
       nil
     end
 
+    # The host refused a sampling field (the empty-answer retry's
+    # temperature on a model that takes none) and the chat loop asked again
+    # without them, as it will for the model from now on: a log line.
+    def sampling_refused(event)
+      Log.info(:model, "sampling_refused", model: event[:model], detail: event[:detail])
+    rescue StandardError
+      nil
+    end
+
     # The host refused the model's reasoning sent back (reasoning_history)
     # and the chat loop asked the step again without it, as it will from
     # now on: logged, and said once per session and host.
@@ -2549,7 +2563,7 @@ module Samagotchi
         context_status: result.context_status&.dup
       }
       # No answer: every UI shows its notice (TurnNote.empty_answer_line).
-      summary[:empty_answer] = { retries: result.empty_retries.to_i } if result.empty_answer?
+      summary[:empty_answer] = { retries: result.empty_retries.to_i, refusal: result.refusal }.compact if result.empty_answer?
       summary
     end
 
@@ -2734,19 +2748,36 @@ module Samagotchi
 
     # ctx.ask_model's request: the session's current model on its host, as
     # a turn resolves them (a /model switch counts), through its own
-    # IdleClient, so it shares nothing with the turn's backend.
+    # IdleClient, so it shares nothing with the turn's backend. The client
+    # is kept while the target and timeout stay (what it learned, e.g. a
+    # refused thinking-off, holds for the next request); the session's id
+    # goes with the request.
     # @return [String] the answer
     def ask_side_model(request, timeout:, max_tokens:, cancel_controller:)
       target = session_model_recap_target
-      client = IdleClient.for(target, timeout: timeout)
+      client = side_model_client(target, timeout)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      answer = client.ask(request, max_tokens: max_tokens, cancel_controller: cancel_controller)
+      answer = client.ask(request, max_tokens: max_tokens, cancel_controller: cancel_controller, session_id: @session&.id)
       Log.info(:plugins, "ask_model", model: target.label, answer_model: answer.model, chars: answer.text.length,
                                       ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       answer.text
     end
     private :ask_side_model
 
+    # The IdleClient for +target+ at +timeout+: the last one when both are
+    # the same, else a new one.
+    def side_model_client(target, timeout)
+      @side_client_mutex.synchronize do
+        key = [target, timeout]
+        unless @side_client && @side_client_key == key
+          @side_client = IdleClient.for(target, timeout: timeout)
+          @side_client_key = key
+        end
+        @side_client
+      end
+    end
+    private :side_model_client
+
     # The session's current model as a recap target: its host's OpenAI API
     # (native llama.cpp hosts serve /v1/chat/completions too), key variable
     # and bare model name, as a turn resolves them.
@@ -2813,6 +2844,7 @@ module Samagotchi
         # reasoning sent back: a notice, not an event of its own.
         next thinking_refused(event) if event[:type] == :thinking_refused
         next reasoning_history_refused(event) if event[:type] == :reasoning_history_refused
+        next sampling_refused(event) if event[:type] == :sampling_refused
 
         event = with_generation_report(event) if event[:type] == :generation_completed
         emit_event(on_event, event)

data/lib/samagotchi/generation_phase.rb

@@ -14,6 +14,12 @@ module Samagotchi
     # A thinking delta this recent means the model is still thinking.
     FRESH_SECONDS = 2.0
 
+    # What a page joining mid-generation needs for its delivery line
+    # (Bridge#snapshot's current_turn.generation): whether it has streamed
+    # only thinking so far (thinking, no text, no tool call; freshness
+    # aside) and its thinking's #age (nil before any thinking).
+    Snapshot = Data.define(:thinking_only, :age)
+
     # @param clock [#call] monotonic seconds
     def initialize(clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       @clock = clock
@@ -71,6 +77,17 @@ module Samagotchi
       @mutex.synchronize { @running && @thinking_since ? @clock.call - @thinking_since : nil }
     end
 
+    # The running generation as a Snapshot, its age rounded to a tenth;
+    # nil with none running.
+    def snapshot
+      @mutex.synchronize do
+        next nil unless @running
+
+        age = @thinking_since && (@clock.call - @thinking_since).round(1)
+        Snapshot.new(thinking_only: !@thinking_since.nil? && !@text && !@tool_call, age: age)
+      end
+    end
+
     private
 
     def clear_seen

data/lib/samagotchi/host_config.rb

@@ -4,6 +4,7 @@ require "uri"
 require_relative "config"
 require_relative "host_model"
 require_relative "llm_context_strategy"
+require_relative "llm/dialect"
 require_relative "reasoning_history"
 
 module Samagotchi
@@ -15,12 +16,20 @@ module Samagotchi
   #
   # name: the lowercased entry name; host, port, scheme: where it is (from
   # url: when given); url: the configured url, nil when host/port; transport,
-  # api: symbols, nil when unset; the rest as HostRegistry::HostEntry
-  # describes them, nil when unset; models: {downcased id => HostModel}.
-  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :profile,
+  # api: symbols, nil when unset; auth: the header the API key goes in
+  # (LLM::ApiKey::SCHEMES), nil when unset; dialect: an api: anthropic
+  # host's LLM::Dialect name, nil when unset; the rest as
+  # HostRegistry::HostEntry describes them, nil when unset; models:
+  # {downcased id => HostModel}.
+  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :auth, :dialect, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models) do
+    # An api: anthropic host without url/host talks to Anthropic's own API.
+    ANTHROPIC_URL = "https://api.anthropic.com"
+    # auth: as written => the LLM::ApiKey scheme.
+    AUTH_SCHEMES = { "bearer" => :bearer, "x-api-key" => :x_api_key }.freeze
+
     # Every field but name may be left out: nil, models {}.
     def initialize(**fields)
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
@@ -69,8 +78,17 @@ module Samagotchi
         return invalid(name, "api_key_env must be an environment variable name")
       end
 
-      location = parse_location(name, value) or return nil
+      auth = value.call(:auth).to_s.strip.downcase
+      fields[:auth] = AUTH_SCHEMES[auth] unless auth.empty?
+      return invalid(name, "auth must be one of #{AUTH_SCHEMES.keys.join(", ")}") if !auth.empty? && fields[:auth].nil?
+
+      if fields[:auth] && fields[:api_key_env].nil?
+        ConfigFile.warn_once "Warning: #{where}: auth has no effect without api_key_env (no key is sent)"
+      end
+
       kinds = parse_kinds(name, value.call(:transport), value.call(:api)) or return nil
+      location = parse_location(name, value, api: kinds[:api]) or return nil
+      fields[:dialect] = LLM::Dialect.parse(value.call(:dialect), where, api: kinds[:api])
       new(name: name.downcase, **location, **kinds, **fields)
     rescue StandardError => e
       # One entry that trips a reader is dropped on its own, and said so;
@@ -99,11 +117,13 @@ module Samagotchi
     end
 
     # host/port/scheme/url from url:, or from host: and port:; nil (warned)
-    # when they are wrong.
-    def self.parse_location(name, value)
+    # when they are wrong. An api: anthropic entry with neither has
+    # ANTHROPIC_URL.
+    def self.parse_location(name, value, api: nil)
       host = value.call(:host)
       port = value.call(:port)
       url = value.call(:url).to_s.strip
+      url = ANTHROPIC_URL if url.empty? && api == :anthropic && host.to_s.strip.empty? && port.to_s.strip.empty?
       scheme = "http"
       unless url.empty?
         return invalid(name, "give url or host/port, not both") unless host.to_s.strip.empty? && port.to_s.strip.empty?
@@ -168,6 +188,7 @@ module Samagotchi
     def to_env_h
       location = url ? { "url" => url } : { "host" => host, "port" => port }
       location.merge("transport" => transport&.to_s, "api" => api&.to_s, "api_key_env" => api_key_env,
+                     "auth" => (AUTH_SCHEMES.key(auth) if auth), "dialect" => dialect,
                      "profile" => profile, "first_token_timeout" => first_token_timeout,
                      "vision" => vision, "sampling" => sampling, "thinking" => thinking&.to_s,
                      "reasoning_history" => reasoning_history&.to_s, "remote" => remote, "window_tokens" => window_tokens,

data/lib/samagotchi/host_registry.rb

@@ -6,7 +6,8 @@ require_relative "log"
 require_relative "model_ref"
 require_relative "client"
 require_relative "model_list_store"
-require_relative "llm/openai_chat"
+require_relative "llm/adapters"
+require_relative "llm/dialect"
 
 module Samagotchi
   # HostRegistry manages multiple model hosts (llama.cpp / mlx / oMLX) and
@@ -30,6 +31,8 @@ module Samagotchi
 
     # url: the configured url, when the entry has one (host, port and scheme
     # come from it); api_key_env: the variable holding the host's API key;
+    # auth: the header it goes in (LLM::ApiKey::SCHEMES), nil for the api's own default;
+    # dialect: an api: anthropic host's LLM::Dialect name (#dialect_profile), nil when unset;
     # profile: the configured prompt profile name, if any;
     # first_token_timeout: the configured first-token limit (see #first_token_limit);
     # vision: the configured true/false (VisionSupport), nil when unset;
@@ -43,13 +46,13 @@ module Samagotchi
     # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
     # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
     # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
-    HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
+    HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :auth, :dialect,
+                           :profile, :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models, keyword_init: true) do
-      # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
-      # raw-prompt loop.
-      def chat? = api == :openai
+      # Talks a chat API through an adapter (LLM::Adapters: the chat loop);
+      # nil and raw apis use the raw-prompt loop.
+      def chat? = LLM::Adapters.chat_api?(api)
 
       # The server root, e.g. for llama.cpp's own endpoints and recap.
       def root_url = "#{scheme || "http"}://#{host}:#{port}"
@@ -58,6 +61,25 @@ module Samagotchi
       # configured, else the root's /v1.
       def openai_base_url = url || "#{root_url}/v1"
 
+      # The API base the host's chat adapter talks to (LLM::Adapters): for
+      # api: openai the OpenAI-compatible base; for api: anthropic the API
+      # root without /v1 (as ANTHROPIC_BASE_URL; a url that ends in /v1
+      # loses it, so requests never go to /v1/v1).
+      def api_base_url
+        return openai_base_url unless api&.to_sym == :anthropic
+
+        (url || root_url).chomp("/").delete_suffix("/v1")
+      end
+
+      # The header the host's key goes in: auth: when set, else the api's
+      # own (for api: anthropic its dialect's, x-api-key unless the dialect
+      # says otherwise; Bearer for every other api).
+      def auth_scheme = auth || (api&.to_sym == :anthropic ? dialect_profile.auth : :bearer)
+
+      # The LLM::Dialect an api: anthropic host's requests follow (STANDARD
+      # when it names none).
+      def dialect_profile = LLM::Dialect.for(dialect)
+
       # A provider on the network rather than a local server: hosts.<name>.remote
       # when set, else by its address (HostRegistry.remote_address?). An API
       # key doesn't decide: a llama.cpp on the LAN can have one. A remote
@@ -106,7 +128,7 @@ module Samagotchi
         entry = HostEntry.new(**fields)
         entry.client = Client.new(host: cfg.host, port: cfg.port, transport: cfg.transport, scheme: cfg.scheme,
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
-                                  api_key_env: entry.api_key_env, env: env)
+                                  api_key_env: entry.api_key_env, auth: entry.auth_scheme, env: env)
         @entries[entry.name] = entry
       end
       # Fallback single entry (should already be synthesized by hosts_config, but guard)
@@ -217,12 +239,13 @@ module Samagotchi
     end
 
     # The chat adapter for a host (one per host, so its cached model list
-    # serves the context window). Only chat hosts use it for turns.
+    # serves the context window), as LLM::Adapters builds it for the host's
+    # api. Only chat hosts use it for turns.
     # @return [LLM::OpenAIChat]
     def adapter_for(entry)
       @mutex.synchronize do
-        @adapters[entry.name] ||= LLM::OpenAIChat.for(entry, models_ttl: entry.models_ttl,
-                                                             first_token_timeout: entry.first_token_limit)
+        @adapters[entry.name] ||= LLM::Adapters.for(entry, models_ttl: entry.models_ttl,
+                                                           first_token_timeout: entry.first_token_limit)
       end
     end
 
@@ -390,7 +413,7 @@ module Samagotchi
     # the registry).
     def inspect
       hosts = @entries.values.map do |entry|
-        parts = [entry.openai_base_url]
+        parts = [entry.api_base_url]
         parts << "key=#{entry.api_key_env}" if entry.api_key_env
         parts << "models=#{entry.models.values.map(&:id).join(",")}" unless entry.models.empty?
         "#{entry.name}(#{parts.join(" ")})"

data/lib/samagotchi/idle_client.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "llm/openai_chat"
-require_relative "thinking"
+require_relative "llm/adapters"
 require_relative "log"
 
 module Samagotchi
   # Standalone summarizer for the idle session-recap feature.
   #
   # Asks an OpenAI-compatible /chat/completions endpoint (the local llama.cpp,
-  # or a recap host's) through its own OpenAIChat: one plain request, no
+  # or a recap host's) through its own adapter (LLM::Adapters.build, by the
+  # target's api; OpenAIChat today): one plain request, no
   # tools, no retries, its own timeout. It is NEVER wired into the Engine's
   # kernel/backend, so it shares no engine concurrency. The Engine's idle
   # detector only snapshots session.messages and calls #summarize; this object
@@ -38,6 +38,11 @@ module Samagotchi
     DEFAULT_TIMEOUT_SECONDS = 30.0
     # Up to 10 sentences (recap.sentences) need ~350 tokens with thinking off.
     MAX_TOKENS = 512
+    # The least max_tokens a side request gets when its model refused
+    # thinking off and the adapter asks for a little thinking instead (an
+    # always-thinking model on a Messages host): the thinking counts in the
+    # limit, so 512 could all go to it and leave no answer.
+    THINKING_MAX_TOKENS = 4096
 
     # @param base_url [String] the OpenAI API base, e.g. http://host:8081/v1
     # @param api_key_env [String, nil] the variable holding the host's key
@@ -46,19 +51,26 @@ module Samagotchi
     #   summarize thread can't outlive the recap attempt by minutes.
     # @param purpose [String] what the requests are for, in the HTTP log
     #   lines and error messages ("recap", "broadcast")
-    def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV, purpose: "recap")
+    # @param api [Symbol] the wire to talk (LLM::Adapters; IdleTarget#api)
+    # @param auth [Symbol, nil] the header the key goes in (IdleTarget#auth)
+    # @param dialect [String, nil] a Messages host's dialect (IdleTarget#dialect)
+    def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV, purpose: "recap",
+                   api: :openai, auth: nil, dialect: nil)
       @model = model
       # A recap is best-effort: one short attempt, no retries. The idle job
-      # tries again after the next activity, never on its own.
-      @chat = LLM::OpenAIChat.new(base_url: base_url.to_s, host_name: purpose, api_key_env: api_key_env,
-                                  stream: false, retries: false, timeout: timeout, env: env, purpose: purpose)
+      # tries again after the next activity, never on its own. Only the
+      # Messages adapter takes a dialect.
+      @chat = LLM::Adapters.build(api: api, base_url: base_url.to_s, host_name: purpose, api_key_env: api_key_env,
+                                  auth: auth, stream: false, retries: false, timeout: timeout, env: env, purpose: purpose,
+                                  **(dialect ? { dialect: dialect } : {}))
     end
 
     # A client for +target+ (an IdleTarget: a recap's, ctx.ask_model's, a
-    # broadcast's triage model).
+    # broadcast's triage model), on its api's adapter.
     # @return [IdleClient]
     def self.for(target, **)
-      new(model: target.model, base_url: target.base_url, api_key_env: target.api_key_env, **)
+      new(model: target.model, base_url: target.base_url, api_key_env: target.api_key_env, api: target.api,
+          auth: target.auth, dialect: target.dialect, **)
     end
 
     THINK_RE = /<\|think\|.*?\|think\|>/m
@@ -86,11 +98,13 @@ module Samagotchi
     # when there is nothing to summarize. Any failure raises SummarizeError
     # (the caller isolates it).
     # @return [Summary, nil]
-    def summarize(prompt)
+    # +session_id+: the session it is about, sent as the turns send it
+    # (Session-Id, a dialect's affinity header), nil for none.
+    def summarize(prompt, session_id: nil)
       messages = prompt.is_a?(Array) ? prompt : [{ role: "user", content: prompt.to_s.strip }]
       return nil if messages.all? { |m| m[:content].to_s.strip.empty? }
 
-      response = generate(messages)
+      response = generate(messages, session_id: session_id)
       cleaned = response.text.to_s.strip
       cleaned.empty? ? nil : Summary.new(text: cleaned, model: response.model)
     rescue SummarizeError
@@ -106,14 +120,15 @@ module Samagotchi
     # @param kind [String] what it is for, in the usage log line
     # @param options [Hash] more request body fields (logprobs: true,
     #   top_logprobs: 5)
+    # @param session_id [String, nil] the session it is about (#summarize)
     # @return [Summary] the answer ("" when the model said nothing)
     # @raise [SummarizeError] any failure but a cancel; its #cause is an
     #   LLM::BadRequest when the host refused the request (+options+ it
     #   doesn't take, say)
     # @raise [LLM::RequestCancelled] +cancel_controller+ was cancelled
-    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, kind: "ask", options: {})
+    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, kind: "ask", options: {}, session_id: nil)
       response = generate(messages, max_tokens: max_tokens, cancel_controller: cancel_controller, whole_sentences: false,
-                                    kind: kind, options: options)
+                                    kind: kind, options: options, session_id: session_id)
       Summary.new(text: response.text.to_s.strip, model: response.model, top_logprobs: response.top_logprobs)
     rescue SummarizeError, LLM::RequestCancelled
       raise
@@ -130,17 +145,15 @@ module Samagotchi
     # the reply has neither content nor reasoning_content. Cut off by
     # +max_tokens+, the text keeps its finished sentences (+whole_sentences+)
     # or all of it, with "…".
-    def generate(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, whole_sentences: true, kind: "recap", options: {})
+    def generate(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, whole_sentences: true, kind: "recap", options: {},
+                 session_id: nil)
       response = begin
-        request(messages, max_tokens, cancel_controller, options)
+        request(messages, max_tokens, cancel_controller, options, session_id)
       rescue LLM::BadRequest => e
-        raise unless e.reasoning_refused? && !@thinking_refused
+        raise unless e.reasoning_refused? && next_thinking_step
 
-        # The host won't turn thinking off (gpt-oss): ask again without the
-        # fields, and leave them out from now on.
-        @thinking_refused = true
-        Log.info(:recap, "thinking_refused", model: @model, detail: e.detail)
-        request(messages, max_tokens, cancel_controller, options)
+        Log.info(:recap, "thinking_refused", model: @model, step: @thinking_step, detail: e.detail)
+        retry
       end
       log_usage(response, kind)
       content = response.text
@@ -173,16 +186,40 @@ module Samagotchi
                                         cached: fields[:cached_tokens], cache_write: fields[:cache_write_tokens])
     end
 
-    def request(messages, max_tokens, cancel_controller, options = {})
+    # After a host refused this step's thinking fields: the next step, kept
+    # from now on (true), or false when none is left.
+    # 1. The host won't turn thinking off (gpt-oss, an always-thinking
+    #    model): the adapter's fields for that (none on the OpenAI API, low
+    #    effort on Messages).
+    # 2. Those refused too (a Messages model that takes no thinking fields
+    #    at all): none.
+    def next_thinking_step
+      step = @thinking_step.to_i
+      return false if step >= 2 || (step == 1 && @chat.thinking_off_refused_fields.empty?)
+
+      @thinking_step = step + 1
+      true
+    end
+
+    def request(messages, max_tokens, cancel_controller, options, session_id)
+      fields = thinking_fields
+      max_tokens = [max_tokens, THINKING_MAX_TOKENS].max if @thinking_step == 1 && !fields.empty?
       @chat.chat(messages: messages, model: @model, tools: [], cancel_controller: cancel_controller,
-                 options: { max_tokens: max_tokens, **thinking_fields, **options })
+                 options: { max_tokens: max_tokens, **fields, **options }, session_id: session_id)
     end
 
     # A recap or side answer is short and tool-less: thinking off, whatever
     # the model's level (a reasoning model otherwise spends the budget
-    # thinking and the recap stops mid-sentence). None once the host refused them.
+    # thinking and the recap stops mid-sentence). Once the host refused
+    # that, the adapter's fields for a model that always thinks (with a
+    # limit of at least THINKING_MAX_TOKENS when there are any), then none
+    # (#next_thinking_step).
     def thinking_fields
-      @thinking_refused ? {} : Thinking.chat_fields(:off)
+      case @thinking_step.to_i
+      when 0 then @chat.thinking_fields(:off)
+      when 1 then @chat.thinking_off_refused_fields
+      else {}
+      end
     end
   end
 end

data/lib/samagotchi/idle_recap.rb

@@ -287,10 +287,13 @@ module Samagotchi
                    sentences: RecapPrompt::DEFAULT_SENTENCES,
                    client: nil,
                    store: nil,
+                   session_id: -> {},
                    clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       raise ArgumentError, "IdleRecap requires an engine" unless engine
 
       @engine = engine
+      # The recapped session's id, sent with the request (IdleClient#summarize).
+      @session_id = session_id
       @target = target || lambda {
         IdleTarget.new(base_url: base_url, api_key_env: api_key_env, model: model, label: model)
       }
@@ -534,7 +537,7 @@ module Samagotchi
     def client_for(asked)
       return @client_override if @client_override
 
-      key = [asked.base_url, asked.api_key_env, asked.model]
+      key = asked
       unless @client && @client_key == key
         @client = IdleClient.for(asked, timeout: @timeout)
         @client_key = key
@@ -544,7 +547,7 @@ module Samagotchi
 
     def spawn_summarize(client, prompt)
       Thread.new do
-        client.summarize(prompt)
+        client.summarize(prompt, session_id: @session_id.call)
       rescue StandardError => e
         # No recap this time (the next idle window tries again); say why.
         Log.exception(:recap, "summarize_failed", e)

data/lib/samagotchi/idle_target.rb

@@ -2,13 +2,28 @@
 
 module Samagotchi
   # Where a side request goes (a recap, a plugin's ctx.ask_model, a
-  # broadcast's triage): a model on a host's OpenAI API, asked through its
+  # broadcast's triage): a model on a host's chat API, asked through its
   # own IdleClient (IdleClient.for), apart from the session's turns.
-  # @!attribute base_url [String] the host's OpenAI API base
+  # @!attribute base_url [String] the host's API base (HostEntry#api_base_url)
   # @!attribute api_key_env [String, nil] the variable holding its key
   # @!attribute model [String] the model id sent to the server
   # @!attribute label [String] the model as configured, for logs
-  IdleTarget = Data.define(:base_url, :api_key_env, :model, :label) do
+  # @!attribute api [Symbol] the wire the side client talks (LLM::Adapters):
+  #   a chat host's api, else :openai (a raw host's server, or a bare url)
+  # @!attribute auth [Symbol, nil] the header its key goes in (the host's
+  #   auth:, LLM::ApiKey::SCHEMES); nil: the api's own default
+  # @!attribute dialect [String, nil] an api: anthropic host's dialect:
+  #   (LLM::Dialect), so a side request gets its auth and fields
+  IdleTarget = Data.define(:base_url, :api_key_env, :model, :label, :api, :auth, :dialect) do
+    def initialize(api: :openai, auth: nil, dialect: nil, **) = super
+
+    # The api a side request to +entry+ talks: a chat host's own, else the
+    # OpenAI API (a raw host's llama.cpp serves /v1 too).
+    def self.api_of(entry) = entry.chat? ? entry.api : :openai
+
+    # The dialect a side request to +entry+ talks (only a chat host has one).
+    def self.dialect_of(entry) = entry.chat? ? entry.dialect : nil
+
     # A configured side model can't be resolved.
     # @!attribute reason [Symbol] :host_ref_unknown (no such host),
     #   :model_host_mismatch (the model names another host than host_ref)
@@ -32,8 +47,9 @@ module Samagotchi
     # @return [IdleTarget]
     def self.of_model(host_registry, name)
       resolved = host_registry.resolve(name)
-      new(base_url: resolved.openai_base_url, api_key_env: resolved.entry.api_key_env, model: resolved.bare_model,
-          label: name.to_s.strip)
+      entry = resolved.entry
+      new(base_url: entry.api_base_url, api_key_env: entry.api_key_env, model: resolved.bare_model,
+          label: name.to_s.strip, api: api_of(entry), auth: entry.auth, dialect: dialect_of(entry))
     end
 
     # A side model's settings (recap.*, broadcast.triage_*) as a target:
@@ -55,12 +71,18 @@ module Samagotchi
 
       host_ref ||= parsed.host_name if parsed && base_url.nil?
       api_key_env = nil
+      api = :openai
+      auth = nil
+      dialect = nil
       if host_ref
         entry = host_registry.find_entry(host_ref)
         raise self::Unresolved.new(:host_ref_unknown, model: model, host_ref: host_ref) unless entry
 
-        base_url = entry.openai_base_url
+        base_url = entry.api_base_url
         api_key_env = entry.api_key_env
+        api = api_of(entry)
+        auth = entry.auth
+        dialect = dialect_of(entry)
         named = parsed&.host_conflict || parsed&.host_name
         if named && named != entry.name
           raise self::Unresolved.new(:model_host_mismatch, model: model, host_ref: host_ref, named: named)
@@ -72,7 +94,8 @@ module Samagotchi
       end
       raise self::Unresolved.new(:incomplete, model: model, host_ref: host_ref) if blank(base_url).nil? || blank(model).nil?
 
-      new(base_url: base_url.to_s.strip, api_key_env: api_key_env, model: model.to_s.strip, label: label.strip)
+      new(base_url: base_url.to_s.strip, api_key_env: api_key_env, model: model.to_s.strip, label: label.strip, api: api, auth: auth,
+          dialect: dialect)
     end
 
     # Whether the settings fix a host (+base_url+, +host_ref+, or a model

data/lib/samagotchi/llm/adapters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "openai_chat"
+require_relative "anthropic_messages"
+
+module Samagotchi
+  module LLM
+    # Which chat adapter talks a host's api: the one place that names the
+    # adapter classes. A host whose api is a key of BY_API runs the chat loop
+    # (HostRegistry::HostEntry#chat?); any other api (nil, raw) the
+    # raw-prompt loop.
+    module Adapters
+      BY_API = { openai: OpenAIChat, anthropic: AnthropicMessages }.freeze
+
+      # true when +api+ (a Symbol or String) has a chat adapter.
+      def self.chat_api?(api) = !api.nil? && BY_API.key?(api.to_sym)
+
+      # A host entry's adapter (its api, API base, name, key and remoteness).
+      # @param entry [HostRegistry::HostEntry]
+      # @param options [Hash] more adapter options (models_ttl:, first_token_timeout:, ...)
+      # @raise [ArgumentError] the entry's api has no chat adapter
+      def self.for(entry, **)
+        adapter_class(entry.api).for(entry, **)
+      end
+
+      # An adapter by api, for a side request that has a url rather than a
+      # host entry (IdleClient: a recap, ctx.ask_model, a broadcast's triage).
+      # @param api [Symbol, String] a key of BY_API
+      # @param options [Hash] more adapter options (stream:, retries:, timeout:, ...)
+      # @raise [ArgumentError] +api+ has no chat adapter
+      def self.build(api:, base_url:, host_name:, api_key_env: nil, **)
+        adapter_class(api).new(base_url: base_url, host_name: host_name, api_key_env: api_key_env, **)
+      end
+
+      def self.adapter_class(api)
+        BY_API.fetch(api&.to_sym) { raise ArgumentError, "no chat adapter for api #{api.inspect}" }
+      end
+      private_class_method :adapter_class
+    end
+  end
+end