samagotchi 0.11.0 → 0.13.0

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

data/lib/samagotchi/llm/model_result.rb

@@ -3,29 +3,20 @@
 module Samagotchi
   module LLM
     # Normalized result returned by every ModelBackend downstream of the agentic
-    # loop. The loop lives INSIDE the backend (Option A), so raw provider tool
-    # calls are never surfaced — `tool_calls` is always `nil` downstream.
-    #
-    # It deliberately mirrors the read surface Engine#run_turn and the renderers
-    # (TerminalUI / Bridge) currently consume off KernelLoop::Result, so wiring
-    # the seam in does not require changes to those consumers:
-    #   .conversation, .canceled?, .cancellation_reason, .output, .exhausted?
-    # plus the native loop's .tool_activity, .context_status and
-    # .pending_tool_calls, which the interactive renderer needs.
+    # loop (the loop lives inside the backend). What Engine#run_turn and the
+    # renderers (TerminalUI / Bridge) read: .output (= .text, and .to_s, which
+    # is how the :turn_completed `result:` reaches JSON), .conversation,
+    # .canceled?, .cancellation_reason, .exhausted?, .resumable?,
+    # .empty_answer?, plus the native loop's .tool_activity, .context_status
+    # and .pending_tool_calls, which the interactive renderer needs.
     class ModelResult
-      attr_reader :text, :tool_calls, :provider, :usage, :metadata,
-                  :conversation, :canceled, :cancellation_reason, :exhausted,
+      attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
                   :tool_activity, :context_status, :pending_tool_calls
 
-      def initialize(text:, tool_calls: nil, provider: nil, usage: nil, metadata: nil,
-                     conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
+      def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
                      tool_activity: [], context_status: nil, pending_tool_calls: false, empty_answer: false)
         @empty_answer = empty_answer
         @text = text
-        @tool_calls = tool_calls
-        @provider = provider
-        @usage = usage
-        @metadata = metadata
         @conversation = conversation
         @canceled = canceled
         @cancellation_reason = cancellation_reason
@@ -44,10 +35,13 @@ module Samagotchi
         !!canceled
       end
 
-      # The turn ended with nothing visible: the text shown is a placeholder,
-      # the conversation holds no reply.
+      # The turn ended with nothing visible: no text, or the chat loop's
+      # placeholder (empty_answer:). A cancelled turn or one that can be
+      # continued is not an empty answer.
       def empty_answer?
-        !!@empty_answer
+        return false if canceled? || resumable?
+
+        !!@empty_answer || text.to_s.strip.empty?
       end
 
       def exhausted?

data/lib/samagotchi/llm/native_backend.rb

@@ -2,12 +2,11 @@
 
 require_relative "backend"
 require_relative "model_result"
-require_relative "usage"
 
 module Samagotchi
   module LLM
     # The raw-prompt loop as a backend: KernelLoop#run (llama.cpp /completion,
-    # Gemma/Qwen prompt formats) with its result wrapped in a ModelResult, so
+    # Gemma/Qwen prompt formats), which returns a ModelResult itself, so
     # Engine and the TUI call every backend the same way.
     class NativeBackend < ModelBackend
       def initialize(kernel:)
@@ -18,32 +17,15 @@ module Samagotchi
 
       def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
-        usage = UsageCollector.new
-        kernel_result = @kernel.run(
+        @kernel.run(
           messages,
           max_iterations: max_iterations,
-          on_stream_event: lambda { |event|
-            usage.observe(event)
-            on_stream_event&.call(event)
-          },
+          on_stream_event: ->(event) { on_stream_event&.call(event) },
           cancel_controller: cancel_controller,
           model_name: model_name,
           max_tool_output_chars: max_tool_output_chars,
           pending_input: pending_input
         )
-        ModelResult.new(
-          text: kernel_result.output.to_s,
-          tool_calls: nil,
-          provider: :native,
-          usage: usage.usage(prompt_text: Array(messages).sum("") { |message| message[:content].to_s }),
-          conversation: kernel_result.conversation,
-          canceled: kernel_result.canceled?,
-          cancellation_reason: kernel_result.cancellation_reason,
-          exhausted: kernel_result.exhausted,
-          tool_activity: kernel_result.tool_activity,
-          context_status: kernel_result.context_status,
-          pending_tool_calls: kernel_result.pending_tool_calls
-        )
       end
     end
   end

data/lib/samagotchi/llm/openai_chat.rb

@@ -56,7 +56,7 @@ module Samagotchi
       # @param entry [HostRegistry::HostEntry]
       def self.for(entry, **options)
         new(base_url: entry.openai_base_url, host_name: entry.name, api_key_env: entry.api_key_env,
-            remote: entry.respond_to?(:remote?) && entry.remote?, **options)
+            remote: entry.remote?, **options)
       end
 
       # Tool arguments as a Hash; "" is {}, invalid JSON stays a String.
@@ -245,12 +245,19 @@ module Samagotchi
           function = call["function"] || {}
           ToolCall.new(id: call["id"], name: function["name"].to_s, arguments: self.class.parse_arguments(function["arguments"]))
         end
-        ChatResponse.new(text: message["content"].to_s,
+        ChatResponse.new(text: OpenAIChat.drop_leading_newlines(message["content"].to_s),
                          reasoning: (message["reasoning_content"] || message["reasoning"]).to_s,
                          tool_calls: calls, usage: Usage.from_payload(body) || Usage.none,
                          finish_reason: body.dig("choices", 0, "finish_reason"), model: served_model(body))
       end
 
+      # Workaround for Splash 1.0.2/1.1.0, which keeps the "\n\n" the model
+      # writes after </think> at the start of the answer
+      # (https://github.com/incoai/splash/issues/254). Remove once Splash
+      # strips it; llama.cpp already does. Streamed, it applies to the chunks
+      # until the first text.
+      def self.drop_leading_newlines(text) = text.sub(/\A[\r\n]+/, "")
+
       def self.served_model(payload)
         model = payload.is_a?(Hash) ? payload["model"] : nil
         model.is_a?(String) && !model.strip.empty? ? model : nil
@@ -372,6 +379,7 @@ module Samagotchi
           @finish_reason = choice["finish_reason"] if choice["finish_reason"]
           delta = choice["delta"].is_a?(Hash) ? choice["delta"] : {}
           content = delta["content"].to_s
+          content = OpenAIChat.drop_leading_newlines(content) if @text.empty?
           reasoning = (delta["reasoning_content"] || delta["reasoning"]).to_s
           @text << content
           @reasoning << reasoning

data/lib/samagotchi/llm/turn_settings.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../thinking"
+
+module Samagotchi
+  module LLM
+    # A turn's settings on the kernel, read by both loops (KernelLoop,
+    # ChatLoop) and ToolRunner: the turn's VisionContext (nil sends no
+    # images, placeholders instead), its request parameters
+    # (SamplingSettings.for; empty sends none), its thinking level
+    # (Thinking.resolve) and the bare model id the turn runs on (every
+    # debug dump is tagged with it). The Engine sets them once per turn,
+    # in Engine#generate, after the model's host is synced.
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name) do
+      # No vision, no sampling, the default thinking, no model name.
+      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil)
+    end
+  end
+end