samagotchi 0.11.0 → 0.12.0

data/lib/samagotchi/host_registry.rb

@@ -229,7 +229,14 @@ module Samagotchi
     # Returns { host_name => { host:, port:, transport:, models: [LLM::ModelInfo], error: nil|String } }
     # Also populates the model index. Unless forced, a host's list is reused
     # for its TTL (60s; 10 minutes for a remote host).
-    def list_all_models(force: true)
+    #
+    # With +wait+ (seconds), answers by one shared deadline: a host still
+    # listing then gets the error "no answer in S s" and its thread is left
+    # running (only for a short-lived process: `chi models`). Such a partial
+    # listing is not stored as the cache or the model index, so a later
+    # resolve doesn't miss the slow host's ids; finished hosts' lists are
+    # kept for their TTL as usual.
+    def list_all_models(force: true, wait: nil)
       results = {}
       results_mutex = Mutex.new
       threads = @entries.map do |name, entry|
@@ -247,7 +254,24 @@ module Samagotchi
           results_mutex.synchronize { results[name] = data }
         end
       end
-      threads.each { |thread| thread.join if thread.is_a?(Thread) }
+      if wait
+        deadline = @clock.call + wait
+        threads.each { |thread| thread.join([deadline - @clock.call, 0].max) if thread.is_a?(Thread) }
+        partial = false
+        # a new hash: the threads keep writing into +results+ (their closure's)
+        snapshot = results_mutex.synchronize do
+          @entries.each_with_object({}) do |(name, entry), acc|
+            acc[name] = results.fetch(name) do
+              partial = true
+              { host: entry.host, port: entry.port, transport: entry.transport, models: [],
+                error: "no answer in #{wait == wait.to_i ? wait.to_i : wait} s" }
+            end
+          end
+        end
+        return snapshot if partial
+      else
+        threads.each { |thread| thread.join if thread.is_a?(Thread) }
+      end
 
       # Model index: model_id downcased -> the hosts listing it, in hosts:
       # order (not the order the threads answered in).

data/lib/samagotchi/idle_reminders.rb

@@ -1,64 +1,42 @@
 # frozen_string_literal: true
 
-require "monitor"
-
-require_relative "reminder_store"
+require_relative "reminder_queue"
 
 module Samagotchi
   # Idle job for periodic reminders — polled by the shared IdleScheduler
   # (one background thread for the whole idle layer).
   #
   # Two delivery paths cooperate:
-  #   1. Pull-based: Engine#collect_due_reminders
-  #      reads ReminderStore#due_reminders at turn start → injects
-  #      [SYSTEM: REMINDERS DUE] → marks all as fired atomically.
+  #   1. Every turn injects what is due (ReminderQueue#inject!, from
+  #      Engine#run_turn) as [SYSTEM: REMINDERS DUE] and marks it fired.
   #   2. Synthetic turns: when this job's tick finds due reminders while
-  #      idle, it latches @due_reminder_name and fires @auto_turn_callback
-  #      (the TUI/SessionManager queue a synthetic turn from the latch).
+  #      idle, it fires @auto_turn_callback, which queues their names
+  #      (Engine#note_due_reminders) for the worker's or the REPL's
+  #      reminder turn. While names are queued the tick waits; whoever
+  #      clears them (a turn's injection, the reminder turn's consumer)
+  #      re-arms it. The queue is the only "already due" state.
   class IdleReminders
     DEFAULT_MIN_INACTIVITY_SECONDS = 60.0 # Minimum idle time before checking for reminders
 
     attr_reader :inactivity
 
     def initialize(engine:, inactivity: DEFAULT_MIN_INACTIVITY_SECONDS,
-                   reminder_store: nil,
+                   queue: nil,
                    clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                    callback: nil)
       raise ArgumentError, "IdleReminders requires an engine" unless engine
 
       @engine = engine
       @inactivity = inactivity
-      @reminder_store = reminder_store || engine.instance_variable_get(:@reminder_store)
+      @queue = queue
       @clock = clock
       @auto_turn_callback = callback
-
-      @mutex = Monitor.new
-      @due_reminder_name = nil
-    end
-
-    # Get all due reminders (from ReminderStore). Called by Engine#collect_due_reminders.
-    # Thread-safe. Returns all due reminders, not just one.
-    # @return [Array<Hash>] [{name:, description:, interval_minutes:}, ...]
-    def due_reminders
-      @reminder_store&.due_reminders || []
-    end
-    # Get the names of all due reminders. Called by the background thread to
-    # determine which reminders need a synthetic turn.
-    # @return [Array<String>] reminder names that are due
-    def due_reminder_names
-      due_reminders.map { |r| r[:name] }
-    end
-
-    # Clear the pending due reminder (after it has been delivered).
-    # Called by Engine after injecting the reminder into the system prompt.
-    def clear_due
-      @mutex.synchronize { @due_reminder_name = nil }
     end
 
     # One detector step, called by the shared IdleScheduler. Public so specs
     # can drive it deterministically.
     def tick
-      return if @due_reminder_name # already due, waiting for engine to deliver
+      return if @queue&.pending? # already queued, waiting for a turn to deliver it
       return unless should_check?
 
       check_due_reminders
@@ -78,14 +56,13 @@ module Samagotchi
     end
 
     def check_due_reminders
-      return unless @reminder_store
-      due_names = @reminder_store.due_reminders.map { |r| r[:name] }
+      return unless @queue
+      due_names = @queue.due.map { |r| r[:name] }
       return if due_names.empty?
       # Signal the engine to create a synthetic turn via callback.
       # The callback is responsible for triggering a turn (e.g. SessionManager
       # writes a file, TerminalUI queues input). The engine's run_turn or
       # REPL injection point then picks up and delivers the reminders.
-      @mutex.synchronize { @due_reminder_name = due_names.first }
       if @auto_turn_callback
         @auto_turn_callback.call(due_names)
       end

data/lib/samagotchi/kernel_loop.rb

@@ -22,6 +22,8 @@ require_relative "tool_activity"
 require_relative "tool_runner"
 require_relative "tool_response"
 require_relative "answer_display"
+require_relative "llm/model_result"
+require_relative "llm/turn_settings"
 
 module Samagotchi
   # The KernelLoop drives the model ↔ tool interaction cycle.
@@ -37,30 +39,12 @@ module Samagotchi
   #   - Gemma 4: <|tool_call>call:NAME{params}<tool_call|>
   #   - Qwen 3.6: <tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>
   class KernelLoop
-    Result = Struct.new(:output, :conversation, :exhausted, :pending_tool_calls, :tool_activity, :canceled, :cancellation_reason, :context_status, keyword_init: true) do
-      def exhausted?
-        exhausted
-      end
-
-      def pending_tool_calls?
-        pending_tool_calls
-      end
-
-      def resumable?
-        exhausted? && pending_tool_calls?
-      end
-
-      def canceled?
-        canceled
-      end
-    end
-
     # The built-in tool classes (Tools::Builtins registers them).
     TOOLS = Tools::Builtins::CLASSES
 
     # What a tool handler (call, kctx) gets from the kernel: the reminder
     # store, the peers, the model key, and the memory read and ask-user
-    # flows that need its state.
+    # flows that need its state (read through the kernel's public readers).
     class ToolContext
       def initialize(kernel)
         @kernel = kernel
@@ -69,8 +53,44 @@ module Samagotchi
       def reminder_store = @kernel.reminder_store
       def peers = @kernel.peers
       def model_key = @kernel.model_key
-      def muted_memory_read(call) = @kernel.__send__(:muted_memory_read, Tools::MemoryRead, call)
-      def ask_user_question(call) = @kernel.__send__(:handle_ask_user_question, call)
+
+      # memory_read with the session's mutes applied: a blank name (the index)
+      # loses the muted memories' lines; a muted name in a comma list is
+      # refused with its own error line and the rest is read as usual.
+      def muted_memory_read(call)
+        muted = Array(@kernel.muted_memory_names)
+        content = call[:content].to_s
+        read = lambda do |names|
+          Tools::MemoryRead.call(names, scope: call[:scope], model_key: model_key, fallback_model_key: @kernel.model_key_fallback)
+        end
+        return read.call(content) if muted.empty?
+        return MutedMemories.filter_index(read.call(content), muted) if content.strip.empty?
+
+        names = Tools::MemoryRead.parse_names(content)
+        refused, allowed = names.partition { |name| MutedMemories.muted?(name, muted) }
+        return read.call(content) if refused.empty?
+
+        errors = refused.map { |name| "Error: memory '#{name}' is muted for this session" }
+        return errors.join("\n") if allowed.empty?
+
+        [read.call(allowed.join(",")), *errors].join(Tools::MemoryRead::SEPARATOR)
+      end
+
+      # ask_user_question: validate the call, then hand the payload to the
+      # Engine's question flow (the kernel's question_handler, which blocks
+      # until the user answers). Without one (headless), the payload as JSON
+      # so the model sees the options and can ask in plain text.
+      def ask_user_question(call)
+        payload = Tools::AskUserQuestion.validate(call)
+        return payload if payload.is_a?(String)
+
+        handler = @kernel.question_handler
+        return JSON.pretty_generate(payload) unless handler
+
+        handler.call(payload).to_s
+      rescue StandardError => e
+        "Error: ask_user_question handler failed: #{e.message}"
+      end
     end
 
     DEFAULT_MAX_TOOL_OUTPUT_CHARS = 10_000
@@ -83,11 +103,12 @@ module Samagotchi
       @client = client || Client.new
       @tools = tools || Tools::Builtins.default
       resolved_model_name = ModelProfile.required_model_name(model_name)
-      # The resolved model id actually used for this run (per-run override wins
+      # The turn's settings (LLM::TurnSettings). Its model name is the
+      # resolved model id actually used for this run (per-run override wins
       # over the config alias); on every debug dump so we can see exactly
-      # which model each request went to. The Engine sets it per turn too:
+      # which model each request went to. The Engine sets them per turn:
       # the chat loop dispatches tools here without going through #run.
-      @current_model_name = resolved_model_name
+      @turn_settings = LLM::TurnSettings.none.with(model_name: resolved_model_name)
       @profile = profile ? ModelProfile.normalize(profile) : ModelProfile.from_model_name(resolved_model_name)
       # Where @profile came from, as /stats shows it (a Resolution's label
       # once the Engine resolves one, see #use_profile!).
@@ -98,24 +119,25 @@ module Samagotchi
       @model_key_fallback = nil
     end
 
-    # @return [ReminderStore, nil] the reminder store for inspection (used by
-    #   Engine to share the same store with the KernelLoop when TerminalUI
-    #   creates both).
-    attr_reader :reminder_store
+    # @return [ReminderStore, nil] the reminder store the reminder tools
+    #   write; the Engine's own (it hands it to a kernel it was given).
+    attr_accessor :reminder_store
 
     # @return [ModelProfile] the active prompt profile
     attr_reader :profile
 
     # @return [Samagotchi::Hooks::Registry, nil] hooks registry shared with Engine.
     #   Engine owns the registry; KernelLoop only fires events. Accessor allows
-    #   Engine to propagate its registry to an externally-created kernel (TUI path).
+    #   Engine to hand its registry to a kernel it is given (specs).
     attr_accessor :hooks
     # @return [Tools::Registry] the tools #dispatch runs. The Engine sets
-    #   its own on a kernel built before it (the REPL's), as with hooks.
+    #   its own on a kernel it is given, as with hooks.
     attr_accessor :tools
     attr_accessor :client
     attr_accessor :model_key
-    attr_accessor :current_model_name
+    # @return [String, nil] the key whose overlay memory_read takes when
+    #   #model_key has none (#sync_model_key!)
+    attr_reader :model_key_fallback
     # @return [Array<String>, nil] the session's muted memories (normalized
     #   names, see MutedMemories); memory_read refuses them. The Engine sets it.
     attr_accessor :muted_memory_names
@@ -125,15 +147,11 @@ module Samagotchi
     # The Guardrails::Gate ToolRunner asks before each call; the Engine sets
     # it (nil: ToolRunner's own, hooks only).
     attr_accessor :guardrail_gate
-    # The turn's VisionContext (images: capability, files, limits), set by
-    # the Engine per turn; nil sends no images (placeholders instead).
-    attr_accessor :vision
-    # The turn's request parameters (SamplingSettings.for), set by the Engine
-    # per turn; empty or nil sends none.
-    attr_accessor :sampling
-    # The turn's thinking level (Thinking.resolve), set by the Engine per
-    # turn; its own accessor, since the native path sends @sampling as is.
-    attr_accessor :thinking
+    # @return [LLM::TurnSettings] the turn's vision, sampling, thinking and
+    #   model name, set by the Engine per turn (#run sets the model name
+    #   too); the thinking level is its own field, since the native path
+    #   sends the sampling as is.
+    attr_accessor :turn_settings
     # Tools::Peers (or the Engine's live view of it): the session
     # list_sessions and send_note speak for; nil outside a session.
     attr_accessor :peers
@@ -142,7 +160,7 @@ module Samagotchi
     # resumable conversation state when execution stops at max_iterations.
     #
     # @param messages       [Array<Hash>]        conversation so far ({role:, content:});
-    #   a stopped run resumes from its Result#conversation
+    #   a stopped run resumes from its result's #conversation
     # @param max_iterations [Integer]            safety cap on tool-call rounds
     # @param on_stream_event [Proc, nil]         optional callback for generation events
     # @param cancel_controller [CancellationController, nil] optional cancellation source
@@ -155,16 +173,16 @@ module Samagotchi
     #   steering mid-stream); drained lines merge into ONE user message appended
     #   at the conversation tail (prefix KV cache preserved) and a
     #   :pending_input_merged stream event is emitted.
-    # @return [Result] final visible response with continuation metadata
+    # @return [LLM::ModelResult] final visible response with continuation metadata
     def run(messages, max_iterations: 100, on_stream_event: nil, cancel_controller: nil, model_name: nil, max_tool_output_chars: nil, pending_input: nil)
-      @current_model_name = completion_model_name(model_name)
+      @turn_settings = @turn_settings.with(model_name: completion_model_name(model_name))
       turn = start_turn(messages, on_stream_event: on_stream_event, cancel_controller: cancel_controller,
                                   pending_input: pending_input, cap: resolve_output_char_cap(max_tool_output_chars))
 
       max_iterations.times do |iteration_index|
         turn.iteration = iteration_index + 1
         outcome = iterate(turn)
-        return outcome if outcome.is_a?(Result)
+        return outcome if outcome.is_a?(LLM::ModelResult)
         break if outcome == :answer
       rescue Client::RequestCancelled => e
         emit(turn, type: :generation_cancelled, iteration: turn.iteration, reason: e.reason)
@@ -220,15 +238,15 @@ module Samagotchi
         # Qwen with thinking off: an empty thought after the cue, so the model
         # answers at once. Kept in the turn's model messages, so each tool-loop
         # prompt starts with what the server already has cached.
-        prefill: Thinking.native(@thinking || Thinking::DEFAULT, @profile).prefill,
-        pending_tool_calls: false, model_name: @current_model_name, pending_input: pending_input,
+        prefill: Thinking.native(@turn_settings.thinking || Thinking::DEFAULT, @profile).prefill,
+        pending_tool_calls: false, model_name: @turn_settings.model_name, pending_input: pending_input,
         on_stream_event: on_stream_event, cancel_controller: cancel_controller, cap: cap,
         emit: ->(event) { emit_stream_event(on_stream_event, event) }
       )
     end
 
     # One iteration. Returns :next, :answer (the turn ends), or the turn's
-    # Result (it ended cancelled).
+    # result (it ended cancelled).
     def iterate(turn)
       inject_pending_input!(turn)
       request = prepare_request(turn)
@@ -264,7 +282,7 @@ module Samagotchi
     end
 
     def format_prompt(turn)
-      Prompt.format_with_images(turn.conversation, profile: @profile, vision: @vision, prefill: turn.prefill)
+      Prompt.format_with_images(turn.conversation, profile: @profile, vision: @turn_settings.vision, prefill: turn.prefill)
     end
 
     # One streamed request, under the generation's own controller: a
@@ -290,7 +308,7 @@ module Samagotchi
           generation_controller: generation_controller,
           cancel_controller: turn.cancel_controller,
           model_name: turn.model_name,
-          sampling: turn.empty_retry.request_sampling(@sampling),
+          sampling: turn.empty_retry.request_sampling(@turn_settings.sampling),
           on_chunk: ->(chunk) { stream_chunk(turn, generation, stream_splitter, chunk) },
           on_retry: lambda { |retry_event|
             # The retry streams from the start: its counts replace these.
@@ -357,7 +375,7 @@ module Samagotchi
     # with its own nudge while the retry budget lasts (queued input goes in
     # place of the nudge), else the turn ends as cancelled (hook), with
     # nothing salvaged and without the spent nudge. A Stop that came right
-    # after the cut is a plain cancel. Returns :next or the turn's Result.
+    # after the cut is a plain cancel. Returns :next or the turn's result.
     def after_cut(turn, generation)
       cut = generation.cut
       raise Client::RequestCancelled.new(turn.cancel_controller.reason) if turn.cancel_controller.cancelled?
@@ -429,20 +447,19 @@ module Samagotchi
       :next
     end
 
-    # The turn's Result. It is exhausted only when it stopped on tool
-    # results it never answered; then the answer shows only its text.
+    # The turn's result. It is exhausted only when it stopped on tool
+    # results it never answered (so exhausted? alone means resumable?);
+    # then the answer shows only its text.
     def finish(turn)
       exhausted = turn.pending_tool_calls && tool_response_turn?(turn.conversation.last)
       output = strip_thought_blocks(last_model_content(turn.conversation))
       output = parser.strip_tool_calls(output) if exhausted
-      Result.new(
-        output: PromptLiteralGuard.restore(output, profile: @profile),
+      LLM::ModelResult.new(
+        text: PromptLiteralGuard.restore(output, profile: @profile).to_s,
         conversation: duplicate_conversation(turn.conversation),
         exhausted: exhausted,
         pending_tool_calls: turn.pending_tool_calls,
         tool_activity: turn.tool_activity,
-        canceled: false,
-        cancellation_reason: nil,
         context_status: turn.context.display
       )
     end
@@ -458,26 +475,6 @@ module Samagotchi
                                                            cancel_controller: turn.cancel_controller, answer: answer)
     end
 
-    # memory_read with the session's mutes applied: a blank name (the index)
-    # loses the muted memories' lines; a muted name in a comma list is
-    # refused with its own error line and the rest is read as usual.
-    def muted_memory_read(tool, call)
-      muted = Array(@muted_memory_names)
-      content = call[:content].to_s
-      read = ->(names) { tool.call(names, scope: call[:scope], model_key: @model_key, fallback_model_key: @model_key_fallback) }
-      return read.call(content) if muted.empty?
-      return MutedMemories.filter_index(read.call(content), muted) if content.strip.empty?
-
-      names = Tools::MemoryRead.parse_names(content)
-      refused, allowed = names.partition { |name| MutedMemories.muted?(name, muted) }
-      return read.call(content) if refused.empty?
-
-      errors = refused.map { |name| "Error: memory '#{name}' is muted for this session" }
-      return errors.join("\n") if allowed.empty?
-
-      [read.call(allowed.join(",")), *errors].join(Tools::MemoryRead::SEPARATOR)
-    end
-
     def emit_stream_event(callback, event)
       callback&.call(event)
     rescue StandardError
@@ -549,14 +546,14 @@ module Samagotchi
       # Only a request with images names them: a text-only call is unchanged.
       kwargs[:images] = images unless images.empty?
       kwargs[:on_chunk] = on_chunk if on_chunk
-      kwargs[:on_retry] = on_retry if on_retry && client_supports_keyword?(:on_retry)
-      kwargs[:cancel_controller] = cancel_controller if cancel_controller && client_supports_keyword?(:cancel_controller)
-      kwargs[:stop] = @profile.stop_sequences if client_supports_keyword?(:stop)
+      kwargs[:on_retry] = on_retry if on_retry
+      kwargs[:cancel_controller] = cancel_controller if cancel_controller
+      kwargs[:stop] = @profile.stop_sequences
       n_predict = completion_n_predict
-      kwargs[:n_predict] = n_predict if n_predict && client_supports_keyword?(:n_predict)
+      kwargs[:n_predict] = n_predict if n_predict
       resolved_model_name = completion_model_name(model_name)
-      kwargs[:model] = resolved_model_name if resolved_model_name && client_supports_keyword?(:model)
-      kwargs[:sampling] = sampling if sampling && !sampling.empty? && client_supports_keyword?(:sampling)
+      kwargs[:model] = resolved_model_name if resolved_model_name
+      kwargs[:sampling] = sampling if sampling && !sampling.empty?
       kwargs
     end
 
@@ -569,19 +566,6 @@ module Samagotchi
       ModelProfile.required_model_name(override)
     end
 
-    def client_supports_keyword?(keyword)
-      @client_complete_keyword_support ||= {}
-      return @client_complete_keyword_support[keyword] if @client_complete_keyword_support.key?(keyword)
-
-      @client_complete_keyword_support[keyword] = begin
-        parameters = @client.method(:complete).parameters
-        parameters.any? { |kind, name| (kind == :key || kind == :keyreq) && name == keyword } ||
-          parameters.any? { |kind, _name| kind == :keyrest }
-      rescue StandardError
-        false
-      end
-    end
-
     def cancelled_result(conversation, tool_activity:, reason:, partial_assistant_text: "")
       partial = partial_assistant_text.to_s.strip
       conversation = duplicate_conversation(conversation)
@@ -592,11 +576,9 @@ module Samagotchi
       unless partial.empty?
         conversation << { role: "model", content: "#{partial}\n[interrupted]", interrupted: true }
       end
-      Result.new(
-        output: "",
+      LLM::ModelResult.new(
+        text: "",
         conversation: conversation,
-        exhausted: false,
-        pending_tool_calls: false,
         tool_activity: tool_activity,
         canceled: true,
         cancellation_reason: reason
@@ -608,7 +590,7 @@ module Samagotchi
     def dump_log(event, payload, **fields)
       return unless Log.level?(:debug)
 
-      Log.debug(:model, event, payload: payload, model: @current_model_name, **fields)
+      Log.debug(:model, event, payload: payload, model: @turn_settings.model_name, **fields)
     end
 
     # Estimate context usage for this iteration's prompt (ContextStatus#observe)
@@ -633,12 +615,6 @@ module Samagotchi
       strip_thought_blocks(text)
     end
 
-    # The status line's context value ({est_pct:, bucket:}) for +used_tokens+
-    # of +window_tokens+; nil without both, or with context.status off.
-    def context_display(used_tokens:, window_tokens:)
-      ContextStatus.new.display_for(used_tokens: used_tokens, window_tokens: window_tokens)
-    end
-
     # Per-profile parse strategy. Rebuilt when the active profile changes
     # (the profile may be re-inferred per run when not explicitly pinned).
     # Public so other loops (and specs) can reach the active profile's parser.
@@ -743,19 +719,5 @@ module Samagotchi
         activity: ToolActivity.tool_activity_event(call[:name], call, result, registry: @tools)
       }
     end
-
-    # ask_user_question: validate the call, then hand the payload to the
-    # Engine's question flow (question_handler, which blocks until the user
-    # answers). Without one (headless), the payload as JSON so the model sees
-    # the options and can ask in plain text.
-    def handle_ask_user_question(call)
-      payload = Samagotchi::Tools::AskUserQuestion.validate(call)
-      return payload if payload.is_a?(String)
-      return JSON.pretty_generate(payload) unless @question_handler
-
-      @question_handler.call(payload).to_s
-    rescue => e
-      "Error: ask_user_question handler failed: #{e.message}"
-    end
   end
 end

data/lib/samagotchi/llm/chat_loop.rb

@@ -77,10 +77,8 @@ module Samagotchi
         end
       end
 
-      # The kernel's tools; the built-ins for a kernel without a registry.
-      def tools
-        @kernel.respond_to?(:tools) ? @kernel.tools : Tools::Builtins.default
-      end
+      # The kernel's tools.
+      def tools = @kernel.tools
 
       # engine-format conversation -> OpenAI wire messages. Model turns are
       # thought-stripped and carry their tool_calls; tool responses go as tool
@@ -133,20 +131,15 @@ module Samagotchi
 
       TOOL_IMAGES_TEXT = "[images from tool results]"
 
-      # The turn's VisionContext (the Engine sets it on the kernel), or nil.
-      def vision
-        @kernel.respond_to?(:vision) ? @kernel.vision : nil
-      end
+      # The turn's VisionContext (the Engine sets the kernel's
+      # turn_settings), or nil.
+      def vision = @kernel.turn_settings.vision
 
-      # The turn's request parameters (the Engine sets them on the kernel).
-      def sampling
-        @kernel.respond_to?(:sampling) ? @kernel.sampling || {} : {}
-      end
+      # The turn's request parameters (the kernel's turn_settings).
+      def sampling = @kernel.turn_settings.sampling || {}
 
-      # The turn's thinking level (the Engine sets it on the kernel).
-      def thinking
-        (@kernel.respond_to?(:thinking) && @kernel.thinking) || Thinking::DEFAULT
-      end
+      # The turn's thinking level (the kernel's turn_settings).
+      def thinking = @kernel.turn_settings.thinking || Thinking::DEFAULT
 
       # The request fields the thinking level adds (Thinking.chat_fields);
       # none for a model whose host refused them (#thinking_refused!).
@@ -171,9 +164,7 @@ module Samagotchi
         deep_compact(options)
       end
 
-      def strip_model_thought(text)
-        @kernel.respond_to?(:strip_model_thought) ? @kernel.strip_model_thought(text) : text
-      end
+      def strip_model_thought(text) = @kernel.strip_model_thought(text)
 
       def tool_runner
         @tool_runner ||= ToolRunner.new(@kernel)
@@ -184,8 +175,7 @@ module Samagotchi
       # llama.cpp answers /props), then the host's model list, config, env
       # and the default. A remote provider has no /props to probe.
       def context_window(model)
-        remote = @adapter.respond_to?(:remote?) && @adapter.remote?
-        client = @kernel.client if !remote && @kernel.respond_to?(:client)
+        client = @adapter.remote? ? nil : @kernel.client
         ContextWindow.resolve(client: client, model: model, adapter: @adapter)
       rescue StandardError
         nil
@@ -193,8 +183,7 @@ module Samagotchi
 
       # A hook failing must not break the turn (as in ToolRunner).
       def fire_hook(name, event)
-        hooks = @kernel.hooks if @kernel.respond_to?(:hooks)
-        hooks&.fire(name, event)
+        @kernel.hooks&.fire(name, event)
       rescue StandardError
         nil
       end
@@ -297,7 +286,7 @@ module Samagotchi
         text.encoding == Encoding::UTF_8 && !text.valid_encoding? ? text.scrub("?") : text
       end
 
-      # One turn's state: the conversation, the stream sink, usage and tool
+      # One turn's state: the conversation, the stream sink and tool
       # activity.
       class Run
         def initialize(loop, conversation, on_stream_event, cancel_controller, model_name, pending_input)
@@ -307,12 +296,7 @@ module Samagotchi
           @cancel_controller = cancel_controller
           @model_name = model_name
           @pending_input = pending_input
-          @usage = UsageCollector.new
           @tool_activity = []
-          # What an estimate counts as the prompt when the server reports no
-          # usage: the text, and each image's estimate (not its base64).
-          @prompt_text = conversation.sum("") { |entry| entry[:content].to_s }
-          @image_tokens = ImagePlan.estimated_tokens(conversation)
           @empty_retry = EmptyAnswerRetry.new
           @context = ContextStatus.new(conversation: conversation)
         end
@@ -578,23 +562,18 @@ module Samagotchi
           @conversation << { role: "model", content: "#{visible}\n[interrupted]", interrupted: true } unless visible.empty?
           conversation = @loop.plain(@conversation)
           conversation.last[:interrupted] = true unless visible.empty?
-          ModelResult.new(text: "", provider: :chat, conversation: conversation, canceled: true,
-                          cancellation_reason: reason, tool_activity: @tool_activity, usage: usage,
+          ModelResult.new(text: "", conversation: conversation, canceled: true,
+                          cancellation_reason: reason, tool_activity: @tool_activity,
                           context_status: @context.display)
         end
 
         def result(text, exhausted:)
-          ModelResult.new(text: text, provider: :chat, conversation: @loop.plain(@conversation), exhausted: exhausted,
-                          tool_activity: @tool_activity, usage: usage, empty_answer: text == EMPTY_ANSWER,
+          ModelResult.new(text: text, conversation: @loop.plain(@conversation), exhausted: exhausted,
+                          tool_activity: @tool_activity, empty_answer: text == EMPTY_ANSWER,
                           context_status: @context.display)
         end
 
-        def usage
-          @usage.usage(prompt_text: @prompt_text, extra_prompt_tokens: @image_tokens)
-        end
-
         def emit(event)
-          @usage.observe(event)
           @on_stream_event&.call(event)
         rescue StandardError
           nil