samagotchi 0.64.0 → 0.66.0

data/lib/samagotchi/engine.rb

@@ -31,6 +31,7 @@ require_relative "llm/backend"
 require_relative "llm/openai_chat"
 require_relative "llm/turn_settings"
 require_relative "session"
+require_relative "toolkit"
 require_relative "answer_tail"
 require_relative "archive_store"
 require_relative "session_observer"
@@ -184,6 +185,9 @@ module Samagotchi
       # plugins' tool sets from chi.replace_tools until the turn thread
       # applies them (#apply_staged_tools!). Built before the plugins load.
       @plugin_tasks = build_plugin_tasks
+      # The toolkits plugins declare (chi.toolkit), beside the built-in and
+      # config ones (#toolkit_kits).
+      @plugin_kits = []
       @lifecycle_mutex = Mutex.new
       @shut_down = false
       load_plugins if plugins
@@ -224,6 +228,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 +304,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 +410,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 +1091,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?
 
@@ -1290,6 +1299,7 @@ module Samagotchi
         llm_context: llm_context_summary,
         thinking: thinking_explained&.summary,
         reasoning_history: reasoning_history_explained&.summary,
+        toolkit: toolkit_summary,
         recap_enabled: !@recap.nil?,
         recap_min_user_turns: @recap&.min_user_turns,
         recap_inactivity_seconds: @recap&.inactivity&.to_i
@@ -1558,11 +1568,12 @@ module Samagotchi
     # (Web::Capabilities#editor), for a UI or a viewer that can't. A UI that
     # does leaves the line out; the others, the log among them, show it. An
     # unknown value is dropped, so the line shows everywhere.
-    def hook_notify(text, level, hook, fallback_for: nil)
+    # +extra+: more fields for the UIs (a toolkit change's summary).
+    def hook_notify(text, level, hook, fallback_for: nil, extra: {})
       level = (level || :info).to_sym
       level = :info unless %i[info warn].include?(level)
       notice = { type: :hook_notice, hook: hook.to_s, text: text.to_s, level: level,
-                 fallback_for: notice_fallback(fallback_for, hook) }.compact
+                 fallback_for: notice_fallback(fallback_for, hook) }.compact.merge(extra)
       return @extension_load.hold(notice) && nil if @extension_load.loading?
 
       in_turn, sink = @turn_state.in_turn_sink
@@ -2014,8 +2025,11 @@ module Samagotchi
       # at its first request).
       start_init_tasks!
       await_init_tasks(turn.controller, turn.on_event)
-      # Plugins' tool sets that changed since the last turn.
+      # Plugins' tool sets that changed since the last turn, then the
+      # session's toolkit (a /toolkit change since the last turn): what the
+      # prompt built next declares, unchanged until the next turn's start.
       apply_staged_tools!
+      apply_toolkit!(session, turn.on_event)
       # A Stop during the wait above: the turn ends here,
       # before the hooks run or a reminder is used up.
       return false if turn.controller.cancelled?
@@ -2285,7 +2299,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 +2496,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 +2572,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
 
@@ -2652,7 +2675,8 @@ module Samagotchi
         init: lambda { |bundle, label, plugin_label, provides_tools:, quiet:, timeout:, failed: nil, &block|
           add_init_task(bundle: bundle, label: label, plugin_label: plugin_label, provides_tools: provides_tools,
                         quiet: quiet, timeout: timeout, failed: failed, &block)
-        }
+        },
+        toolkits: @plugin_kits
       )
       # What plugins show while they load (an MCP server that didn't
       # start) waits for the first turn, beside the load warnings: no UI
@@ -2675,6 +2699,101 @@ module Samagotchi
     end
     public :apply_staged_tools!
 
+    # The kits a session's toolkit resolves against: the built-ins, config's
+    # toolkit.kits, the plugins' (Toolkit.kits). Config's are read once per
+    # process, like the plugins': an edit to toolkit.kits never changes a
+    # live session's tools mid-session (a new worker reads it).
+    # @param errors [Array<String>] gets a line per config kit left out
+    # @return [Hash{String => Toolkit::Kit}]
+    def toolkit_kits(errors = [])
+      @config_kits = Toolkit.config_kits unless defined?(@config_kits)
+      Toolkit.kits(config: @config_kits, plugins: @plugin_kits, errors: errors)
+    end
+
+    # The session's toolkit resolved (Toolkit::Resolved): what its next
+    # turn declares. A plain full toolkit is nil, the Registry's "every tool".
+    def resolved_toolkit(session, errors = [])
+      resolved = Toolkit.of(session&.toolkit).resolve(toolkit_kits(errors))
+      resolved.everything? ? nil : resolved
+    end
+
+    # The tools this session registered (Tools::Registry), declared or not.
+    attr_reader :tools
+
+    # +toolkit+ (the session's by default) as its next turn would declare
+    # it (/toolkit, the UIs' chip).
+    # @return [Toolkit::Explained]
+    def toolkit_explained(toolkit = nil)
+      toolkit ||= Toolkit.of(@session&.toolkit)
+      resolved = toolkit.resolve(toolkit_kits)
+      filter = resolved.everything? ? nil : resolved
+      Toolkit::Explained.new(toolkit: toolkit, resolved: resolved, declared: @tools.entries(toolkit: filter),
+                             left_out: @tools.left_out_names(toolkit: filter), pending: filter != @tools.toolkit)
+    end
+
+    # The session's toolkit for the UIs (the snapshot, command_ran): nil on
+    # full, or with no session.
+    def toolkit_summary
+      @session && toolkit_explained.summary
+    end
+    public :tools, :toolkit_kits, :resolved_toolkit, :toolkit_explained, :toolkit_summary
+
+    # A plugin's ctx.use_toolkit: put the session on toolkit +name+, saved,
+    # when it has no model reply yet and no turn runs (D3: no confirm from
+    # plugins), and tell the user as /toolkit would; it applies at the next
+    # turn's start.
+    # @return [Boolean] whether it was staged
+    # @raise [ArgumentError] an unknown toolkit
+    def use_toolkit(name)
+      raise ArgumentError, "no toolkit named #{name}" unless toolkit_kits.key?(name)
+      return false if @session.nil? || turn_running? || history?
+
+      toolkit = Toolkit.new(name: name)
+      return true if @session.toolkit == toolkit
+
+      @session.toolkit = toolkit
+      @session.save(state_dir: session_state_dir)
+      hook_notify("toolkit: #{name} from the next turn's start", :info, "toolkit", extra: { toolkit: toolkit_summary })
+      true
+    end
+    public :use_toolkit
+
+    # Resolve the session's toolkit into the Registry, on the turn thread at
+    # a turn's start (before its prompt is built), and build the prompts
+    # again when what it declares changed. A name that doesn't resolve (a
+    # typo, an uninstalled bundle) declares everything for now and says so
+    # once; the saved toolkit stays as it is.
+    # @return [Boolean] whether the declared tools changed
+    def apply_toolkit!(session, on_event = nil)
+      errors = []
+      resolved = Toolkit.of(session&.toolkit).resolve(toolkit_kits(errors))
+      warn_toolkit(session, resolved, errors, on_event)
+      resolved = nil if resolved.everything?
+      return false if resolved == @tools.toolkit
+
+      @tools.toolkit = resolved
+      @prompt_builder&.reset!
+      true
+    end
+    private :apply_toolkit!
+
+    # The toolkit's load warnings, each once per process: a name that
+    # didn't resolve, config kits left out.
+    def warn_toolkit(session, resolved, errors, on_event)
+      lines = errors.dup
+      if resolved.fallback
+        lines << "#{Toolkit.of(session&.toolkit).label}: #{resolved.fallback}; this session declares every tool (full) " \
+                 "until it resolves"
+      end
+      @toolkit_warned ||= []
+      (lines - @toolkit_warned).each do |line|
+        @toolkit_warned << line
+        Log.warn(:config, "toolkit_unresolved", message: line)
+        emit_event(on_event, { type: :guardrail_warning, message: line, label: "toolkit" })
+      end
+    end
+    private :warn_toolkit
+
     # The tools changed (a plugin's chi.tools_changed!): the system prompts,
     # which declare them, are built again on the next turn.
     def tools_changed!
@@ -2701,6 +2820,9 @@ module Samagotchi
         steer: ->(text, label) { steer(text, source: hook_source(label)) },
         stop_turn: ->(reason, label) { hook_stop_turn(reason, label) },
         stop_generation: ->(reason, label) { hook_stop_generation(reason, label) },
+        toolkit: -> { @session && Toolkit.of(@session.toolkit).name },
+        declared_tools: -> { toolkit_explained.declared.map(&:name) },
+        use_toolkit: ->(name) { use_toolkit(name) },
         ask_model: lambda { |request, timeout:, max_tokens:, cancel_controller:|
           ask_side_model(request, timeout: timeout, max_tokens: max_tokens, cancel_controller: cancel_controller)
         },
@@ -2734,19 +2856,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 +2952,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