samagotchi 0.2.0 → 0.4.0

data/lib/samagotchi/kernel_loop.rb

@@ -10,13 +10,17 @@ require_relative "prompt_literal_guard"
 require_relative "client"
 require_relative "llm/errors"
 require_relative "log"
+require_relative "empty_answer_retry"
+require_relative "thinking"
 require_relative "hooks"
 require_relative "pending_input_queue"
+require_relative "steer"
 require_relative "thought_stream_splitter"
 require_relative "tools/builtins"
 require_relative "muted_memories"
 require_relative "tool_activity"
 require_relative "tool_runner"
+require_relative "answer_display"
 
 module Samagotchi
   # The KernelLoop drives the model ↔ tool interaction cycle.
@@ -173,6 +177,12 @@ module Samagotchi
     # 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
     # 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
@@ -206,15 +216,22 @@ module Samagotchi
       tool_activity = []
       qwen_recovery_attempts = 0
       qwen_partial_tool_call = nil
+      empty_retries = 0
+      empty_retry_limit = EmptyAnswerRetry.limit
+      @retry_generation = false
       context_status = nil
       stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
+      # 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
       partial_assistant_buffer = +""
 
       effective_max_iterations = @no_interrupt ? 1000 : max_iterations
       effective_max_tool_output_chars = resolve_output_char_cap(max_tool_output_chars)
       effective_max_iterations.times do |iteration_index|
         inject_pending_input!(conversation, pending_input, on_stream_event, iteration_index + 1, cancel_controller)
-        prompt, images = Prompt.format_with_images(conversation, profile: @profile, vision: @vision)
+        prompt, images = Prompt.format_with_images(conversation, profile: @profile, vision: @vision, prefill: prefill)
         image_tokens = images.empty? ? 0 : ImagePlan.estimated_tokens(conversation)
         context_window = ContextWindow.resolve(client: @client, model: resolved_model_name)
         context_status = emit_context_status_event(on_stream_event, prompt, iteration_index: iteration_index, state: context_state, window: context_window,
@@ -223,7 +240,7 @@ module Samagotchi
           # The model's own copy, on the tail (the prompt cache keeps its
           # prefix), then the prompt again with it.
           conversation << line
-          prompt, images = Prompt.format_with_images(conversation, profile: @profile, vision: @vision)
+          prompt, images = Prompt.format_with_images(conversation, profile: @profile, vision: @vision, prefill: prefill)
         end
         emit_stream_event(
           on_stream_event,
@@ -299,9 +316,9 @@ module Samagotchi
         # Fire :after_generation hook (after LLM returns, before tool parse),
         # with a read-only copy of the conversation as sent.
         after_gen_event = { type: :after_generation, iteration: iteration_index + 1, response: response,
-                            messages: conversation.map(&:dup).freeze }
+                            messages: AnswerDisplay.strip_all(conversation).map(&:dup).freeze }
         fire_hook(:after_generation, after_gen_event) if @hooks
-        conversation << { role: "model", content: response }
+        conversation << { role: "model", content: prefill + response.to_s }
 
         # Profile-specific parse (incl. Qwen unterminated-block recovery); the
         # returned fragment (non-nil only for Qwen) is fed back on the next
@@ -322,7 +339,25 @@ module Samagotchi
 
           pending_tool_calls = false
           answer = -> { PromptLiteralGuard.restore(strip_thought_blocks(response), profile: @profile) }
-          unless inject_pending_input!(conversation, pending_input, on_stream_event, iteration_index + 1, cancel_controller, answer: answer)
+          empty = strip_thought_blocks(response.to_s).strip.empty?
+          retry_empty = empty && empty_retries < empty_retry_limit && !cancel_controller&.cancelled?
+          # The empty generation goes (its thinking would be sent again and
+          # prime the same loop); an empty answer that will be retried is no
+          # answer site, so a plugin's steer joins the retry.
+          conversation.pop if retry_empty
+          unless inject_pending_input!(conversation, pending_input, on_stream_event, iteration_index + 1, cancel_controller,
+                                       answer: retry_empty ? nil : answer)
+            if retry_empty
+              empty_retries += 1
+              @retry_generation = true
+              emit_stream_event(on_stream_event, type: :empty_answer_retry, iteration: iteration_index + 1,
+                                                 attempt: empty_retries, of: empty_retry_limit,
+                                                 thinking_chars: thinking_chars(response.to_s, streamed_thinking))
+              conversation << TurnNote.empty_retry
+              next
+            end
+            # The Engine's TurnNote.empty says it all: the spent nudge goes.
+            drop_last_empty_retry!(conversation) if empty && empty_retries.positive?
             break
           end
           # Queued steering keeps the turn going: loop again so the model
@@ -338,6 +373,7 @@ module Samagotchi
         image_counts = []
         shown_params = []
         shown_labels = []
+        diffs = []
         results = calls.map.with_index do |call, call_index|
           run = tool_runner.run(call, iteration: iteration_index + 1, call_index: call_index + 1,
                                       call_count: calls.length, on_stream_event: on_stream_event,
@@ -347,6 +383,7 @@ module Samagotchi
           image_counts << Array(run[:images]).size
           shown_params << run[:shown_params]
           shown_labels << run[:shown_label]
+          diffs << run[:diff]
           run[:output]
         end.join("\n\n---\n\n")
         emit_stream_event(on_stream_event, type: :tool_dispatch_completed, iteration: iteration_index + 1, call_count: calls.length)
@@ -360,6 +397,9 @@ module Samagotchi
         # a built-in), for the web's reload; the prompt never reads it.
         tool_response[:tool_params] = shown_params if shown_params.any?
         tool_response[:tool_labels] = shown_labels if shown_labels.any?
+        # What each edit/write changed (nil for other calls), in call order,
+        # for the web's reload; the prompt never reads it.
+        tool_response[:tool_diffs] = diffs if diffs.any?
         conversation << tool_response
         pending_tool_calls = true
       rescue Client::RequestCancelled => e
@@ -437,6 +477,8 @@ module Samagotchi
     # append them as ONE merged user message at the conversation tail and emit
     # :pending_input_merged. Tail-append only: head mutation would invalidate
     # the server-side prefix KV cache. Returns true when a message was injected.
+    # A plugin's steers (Steer) follow the user's message, each its own
+    # message; after an answer the Engine's drain has already dropped them.
     # After a cancel the input stays queued: it runs as the next turn instead
     # of dying with this one. +answer+ (a proc, called only on a merge) is the
     # answer the merge follows: the UIs show it, the turn summary has only the
@@ -445,24 +487,16 @@ module Samagotchi
       return false unless pending_input
       return false if cancel_controller&.cancelled?
 
-      lines = begin
-        pending_input.call
-      rescue StandardError
-        nil
-      end
-      return false if lines.nil? || lines.empty?
-
-      content = lines.map { |line| line.to_s.strip }.reject(&:empty?).join("\n\n")
-      return false if content.empty?
+      merge = Steer.merge(Steer.drain(pending_input, at_answer: !answer.nil?))
+      return false if merge.empty?
 
       answer = answer.call.to_s if answer
-      conversation << { role: "user", content: content }
+      conversation.concat(merge.messages)
       emit_stream_event(
         on_stream_event,
         type: :pending_input_merged,
         iteration: iteration,
-        count: lines.length,
-        content: content,
+        **merge.event_fields,
         answer: answer.to_s.strip.empty? ? nil : answer
       )
       true
@@ -524,6 +558,9 @@ module Samagotchi
       kwargs[:n_predict] = n_predict if n_predict && client_supports_keyword?(:n_predict)
       resolved_model_name = completion_model_name(model_name)
       kwargs[:model] = resolved_model_name if resolved_model_name && client_supports_keyword?(:model)
+      sampling = @retry_generation ? EmptyAnswerRetry.sampling(@sampling) : @sampling
+      @retry_generation = false
+      kwargs[:sampling] = sampling if sampling && !sampling.empty? && client_supports_keyword?(:sampling)
       kwargs
     end
 
@@ -804,14 +841,6 @@ module Samagotchi
       end
     end
 
-    # Parse tool calls from raw model output using the active profile's
-    # ToolCallParser strategy (Gemma 4 or Qwen 3.6).
-    # Thought content is intentionally left intact while a tool-call turn is in
-    # progress to preserve same-turn reasoning context between tool calls.
-    def parse_tool_calls(text)
-      parser.parse(text.to_s)
-    end
-
     public
 
     # Public wrapper so other loops (e.g. the chat loop) can strip
@@ -862,7 +891,9 @@ module Samagotchi
     def sanitize_history(messages)
       messages.map do |m|
         if m[:role] == "model"
-          { role: m[:role], content: strip_thought_blocks(m[:content].to_s) }
+          # `display` rides along so the stored conversation keeps it; the
+          # prompt formatter never reads it (AnswerDisplay).
+          { role: m[:role], content: strip_thought_blocks(m[:content].to_s), display: m[:display] }.compact
         else
           m.dup
         end
@@ -882,6 +913,12 @@ module Samagotchi
       messages.map(&:dup)
     end
 
+    def drop_last_empty_retry!(conversation)
+      nudge = TurnNote.empty_retry
+      index = conversation.rindex { |entry| entry[:kind] == nudge[:kind] && entry[:content] == nudge[:content] }
+      conversation.delete_at(index) if index
+    end
+
     def last_model_content(conversation)
       message = conversation.reverse.find { |entry| entry[:role] == "model" }
       message ? message[:content].to_s : ""
@@ -942,76 +979,18 @@ module Samagotchi
       }
     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)
-      question = (call[:question] || call[:content]).to_s.strip
-      raw_opts = call[:options]
-      # Dumb-model tolerant: raw may be String JSON, Array, or malformed with brackets/quotes
-      options = Samagotchi::Tools::AskUserQuestion.normalize_options_lenient(raw_opts)
-      # Fallback for case where raw was String like '["a","b"]' but lenient returned [] due to edge parse, try raw string of params
-      if options.empty? && raw_opts.is_a?(String)
-        options = Samagotchi::Tools::AskUserQuestion.normalize_options_lenient(raw_opts.to_s)
-      end
-      header = call[:header].to_s.strip
-      header = nil if header.empty?
-      multi = call[:multi_select]
-      free = call[:allow_freeform]
-      # Normalize booleans from string forms (Gemma passes "true"/"false" as strings)
-      multi = normalize_ask_bool(multi)
-      free = normalize_ask_bool(free)
-
-      if question.empty?
-        return "Error: ask_user_question requires 'question'"
-      end
-      # Dumb-model tolerant: salvage single-option parse glitches, but still require at least 1
-      if options.size < 1
-        alt = Samagotchi::Tools::AskUserQuestion.normalize_options_lenient(call[:content].to_s) if call[:content]
-        options = alt unless alt.empty?
-      end
-      if options.empty?
-        return "Error: ask_user_question requires 2-8 options (got 0). Provide e.g. options=[\"Cats\",\"Dogs\"]"
-      end
-      if options.size == 1
-        # Allow single-option salvage for dumb models (will still render, user can answer or provide freeform)
-      elsif options.size < 2 || options.size > 8
-        return "Error: ask_user_question requires 2-8 options (got #{options.size}). Provide e.g. options=[\"Cats\",\"Dogs\"]"
-      end
-
-      # If an Engine-level blocking handler is registered (TUI/Web), delegate
-      # there (Engine sets question_handler). Otherwise fall back to a
-      # non-blocking JSON preview so the model can still see a structured response.
-      handler = @question_handler
-
-      payload = {
-        question: question,
-        options: options,
-        header: header,
-        multi_select: !!multi,
-        allow_freeform: !!free
-      }.compact
-
-      if handler
-        begin
-          result = handler.call(payload)
-          return result.to_s
-        rescue => e
-          return "Error: ask_user_question handler failed: #{e.message}"
-        end
-      end
-
-      # Headless fallback: return JSON so model sees structured options and can
-      # fallback to plain text qualification.
-      JSON.pretty_generate(payload)
-    end
-
-    def normalize_ask_bool(v)
-      return nil if v.nil?
-      return v if v == true || v == false
-
-      s = v.to_s.strip.downcase
-      return true if %w[1 true yes on].include?(s)
-      return false if %w[0 false no off].include?(s)
+      payload = Samagotchi::Tools::AskUserQuestion.validate(call)
+      return payload if payload.is_a?(String)
+      return JSON.pretty_generate(payload) unless @question_handler
 
-      nil
+      @question_handler.call(payload).to_s
+    rescue => e
+      "Error: ask_user_question handler failed: #{e.message}"
     end
   end
 end

data/lib/samagotchi/live_versions.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "socket"
+require_relative "session"
+require_relative "version"
+
+module Samagotchi
+  # Which chi versions the running processes run, for `chi update`: session
+  # workers (their bridge.json sidecar names the version since chi update exists; an
+  # older one names none) and a `chi web` on its port (/api/info). Read-only:
+  # a dead worker's sidecar is left for the next client to clean up.
+  module LiveVersions
+    PROBE_TIMEOUT = 0.2
+    WEB_TIMEOUT = 0.5
+
+    # version is nil for a sidecar written before sidecars carried one.
+    Worker = Struct.new(:session_id, :version, keyword_init: true)
+
+    module_function
+
+    # @return [Array<Worker>] the workers whose Bridge answers, by session id
+    def workers(state_dir: Session.default_state_dir)
+      Dir[File.join(state_dir, "*", "bridge.json")].sort.filter_map do |sidecar|
+        data = JSON.parse(File.read(sidecar))
+        next unless data.is_a?(Hash) && listening?(data["port"].to_i)
+
+        Worker.new(session_id: File.basename(File.dirname(sidecar)), version: data["version"])
+      rescue JSON::ParserError, SystemCallError
+        nil
+      end
+    end
+
+    # The live workers on another version than +version+ (unknown counts).
+    def stale_workers(version = VERSION, state_dir: Session.default_state_dir)
+      workers(state_dir: state_dir).reject { |w| w.version == version }
+    end
+
+    # The version a chi web on host:port runs, or nil when nothing (or not
+    # chi web) answers.
+    def web_version(host, port, timeout: WEB_TIMEOUT)
+      response = Net::HTTP.start(host, port, open_timeout: timeout, read_timeout: timeout) { |http| http.get("/api/info") }
+      info = response.code.to_i == 200 ? JSON.parse(response.body.to_s) : nil
+      info.is_a?(Hash) && info["app"] == "chi-web" ? info["version"].to_s : nil
+    rescue StandardError
+      nil
+    end
+
+    def listening?(port, host: "127.0.0.1")
+      return false unless port.positive?
+
+      Socket.tcp(host, port, connect_timeout: PROBE_TIMEOUT).close
+      true
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/samagotchi/llm/api_key.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Samagotchi
+  module LLM
+    # A host's API key: the environment variable its api_key_env: names,
+    # sent as `Authorization: Bearer <key>` on every request LLM::HTTP makes
+    # for the host (llama.cpp started with --api-key, or a provider). The
+    # key itself never goes into a message.
+    ApiKey = Data.define(:env_name, :host, :env) do
+      # nil for a host without api_key_env: its requests carry no header.
+      def self.for(env_name, host:, env: ENV)
+        name = env_name.to_s.strip
+        name.empty? ? nil : new(env_name: name, host: host.to_s, env: env)
+      end
+
+      # What to try after a 401/403 from a host that has no api_key_env.
+      def self.missing_hint(host)
+        "the server may want an API key: put it in an environment variable and name it with api_key_env: on host #{host}"
+      end
+
+      # Sets the header, or raises AuthError when the variable is not set.
+      def authorize(request)
+        key = env[env_name].to_s
+        raise AuthError.new("#{host}: set #{env_name} (the API key for host #{host})", host: host) if key.strip.empty?
+
+        request["Authorization"] = "Bearer #{key}"
+      end
+
+      # What to try after a 401/403 with the key sent.
+      def hint = "check #{env_name} (the API key for host #{host})"
+
+      # Without the environment: it holds this key and every other secret.
+      def inspect = "#<#{self.class.name} #{env_name} host=#{host}>"
+      alias_method :to_s, :inspect
+
+      def pretty_print(printer) = printer.text(inspect)
+    end
+  end
+end

data/lib/samagotchi/llm/chat_loop.rb

@@ -8,12 +8,16 @@ require_relative "usage"
 require_relative "openai_chat"
 require_relative "native_tool_normalizer"
 require_relative "../kernel_loop"
+require_relative "../answer_display"
 require_relative "../context_window"
 require_relative "../context_note"
 require_relative "../tool_runner"
 require_relative "../tool_declarations"
 require_relative "../vision_context"
 require_relative "../log"
+require_relative "../empty_answer_retry"
+require_relative "../turn_note"
+require_relative "../thinking"
 
 module Samagotchi
   module LLM
@@ -131,6 +135,39 @@ module Samagotchi
         @kernel.respond_to?(:vision) ? @kernel.vision : nil
       end
 
+      # The turn's request parameters (the Engine sets them on the kernel).
+      def sampling
+        @kernel.respond_to?(:sampling) ? @kernel.sampling || {} : {}
+      end
+
+      # The turn's thinking level (the Engine sets it on the kernel).
+      def thinking
+        (@kernel.respond_to?(:thinking) && @kernel.thinking) || Thinking::DEFAULT
+      end
+
+      # The request fields the thinking level adds (Thinking.chat_fields);
+      # none for a model whose host refused them (#thinking_refused!).
+      def thinking_fields(model = nil)
+        return {} if model && (@thinking_refused ||= Set.new).include?(model)
+
+        Thinking.chat_fields(thinking)
+      end
+
+      # The host refused +model+'s thinking fields: leave them out from now on.
+      def thinking_refused!(model)
+        (@thinking_refused ||= Set.new) << model
+      end
+
+      # One generation's options: the thinking fields under the sampling
+      # (a sampling key wins, chat_template_kwargs merges per sub-key), the
+      # empty-answer retry's temperature on top, then every null dropped at
+      # any depth (a sampling null means "don't send it").
+      def request_options(retry_generation: false, model: nil)
+        options = deep_merge(thinking_fields(model), sampling)
+        options = EmptyAnswerRetry.sampling(options) if retry_generation
+        deep_compact(options)
+      end
+
       def strip_model_thought(text)
         @kernel.respond_to?(:strip_model_thought) ? @kernel.strip_model_thought(text) : text
       end
@@ -172,7 +209,7 @@ module Samagotchi
       # reasoning, never sent back), a result's tool_call_id, the image
       # refs of a user message or a tool result, and a plugin tool result's
       # tool_params and tool_labels (the live row's params line and label,
-      # never sent back).
+      # never sent back), and an edit/write result's tool_diffs (never sent).
       def plain(conversation)
         conversation.map do |entry|
           content = entry[:content].is_a?(Array) ? entry[:content] : entry[:content].to_s
@@ -183,6 +220,8 @@ module Samagotchi
           message[:thinking] = entry[:thinking] if entry[:thinking].is_a?(String) && !entry[:thinking].empty?
           message[:tool_params] = entry[:tool_params] if entry[:tool_params]
           message[:tool_labels] = entry[:tool_labels] if entry[:tool_labels]
+          message[:tool_diffs] = entry[:tool_diffs] if entry[:tool_diffs]
+          message[AnswerDisplay::KEY] = entry[AnswerDisplay::KEY] if entry[AnswerDisplay::KEY]
           ContextNote::KEYS.each { |key| message[key] = entry[key] if entry.key?(key) }
           message
         end
@@ -190,6 +229,18 @@ module Samagotchi
 
       private
 
+      def deep_merge(base, over)
+        base.merge(over) { |_key, a, b| a.is_a?(Hash) && b.is_a?(Hash) ? deep_merge(a, b) : b }
+      end
+
+      def deep_compact(hash)
+        hash.each_with_object({}) do |(key, value), out|
+          next if value.nil?
+
+          out[key] = value.is_a?(Hash) ? deep_compact(value) : value
+        end
+      end
+
       # Ids of the calls whose assistant turn is followed by a tool message
       # for every one of them (before the next non-tool message).
       def paired_call_ids(conversation)
@@ -268,6 +319,8 @@ module Samagotchi
           # 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_retries = 0
+          @empty_retry_limit = EmptyAnswerRetry.limit
         end
 
         EMPTY_ANSWER = "(the model returned an empty answer)"
@@ -288,7 +341,12 @@ module Samagotchi
               # Kept before a merge too: the model answers the merged line
               # knowing what it just said.
               @conversation << with_thinking({ role: "model", content: last_text }, response) unless last_text.empty?
-              next if inject_pending_input(iteration, answer: last_text)
+              retry_empty = last_text.empty? && retry_empty_answer?(iteration, response)
+              # An empty answer that will be retried is no answer site: a
+              # plugin's steer joins the retry instead of being dropped, and
+              # queued input (a user's line, a steer) goes in place of the nudge.
+              next if inject_pending_input(iteration, answer: retry_empty ? nil : last_text)
+              next if retry_empty && nudge_empty_answer(iteration, response)
 
               # Shown, not saved: an empty answer (content "" + stop, seen from
               # a remote host) would otherwise end the turn with nothing.
@@ -310,6 +368,31 @@ module Samagotchi
 
         private
 
+        # A retry is left, and the answer wasn't cut short by a full context
+        # (a length stop while thinking is retried: a thinking loop cut by
+        # the provider's output cap, not a full window).
+        def retry_empty_answer?(iteration, response)
+          return false if @empty_retries >= @empty_retry_limit || @cancel_controller&.cancelled?
+
+          if response.finish_reason.to_s == "length" &&
+             EmptyAnswerRetry.context_full?(response.usage&.total_tokens, @window&.tokens)
+            Log.info(:turn, "empty_answer_not_retried", iteration: iteration, why: "context full")
+            return false
+          end
+          true
+        end
+
+        # The hidden nudge before the next generation (EmptyAnswerRetry),
+        # which runs at the retry temperature. Returns true.
+        def nudge_empty_answer(iteration, response)
+          @empty_retries += 1
+          @retry_generation = true
+          emit(type: :empty_answer_retry, iteration: iteration, attempt: @empty_retries, of: @empty_retry_limit,
+               finish_reason: response.finish_reason, thinking_chars: response.reasoning.to_s.length)
+          @conversation << TurnNote.empty_retry
+          true
+        end
+
         # The host's reasoning, kept on the model message as +thinking+ for
         # the web turn view's reload (the whole of it, as the live view
         # shows). Only saved: #assistant_message builds the wire message from
@@ -322,14 +405,40 @@ module Samagotchi
         # One streamed request. Returns [response, nil], or [reason, partial
         # text] when it was cancelled.
         def generate(iteration)
-          window = @loop.context_window(@model_name)
+          window = @window = @loop.context_window(@model_name)
+          retry_generation = @retry_generation
+          @retry_generation = false
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
                context_window_source: window&.source)
           @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
           streamed = +""
-          response = @loop.adapter.chat(
+          response = begin
+            request(iteration, retry_generation, streamed)
+          rescue BadRequest => e
+            raise unless thinking_refused?(e)
+
+            # Once per model: asked again without the thinking fields.
+            @loop.thinking_refused!(@model_name)
+            emit(type: :thinking_refused, iteration: iteration, model: @model_name, level: @loop.thinking, detail: e.detail)
+            request(iteration, retry_generation, streamed)
+          end
+          record_context_status(response.usage, window)
+          emit(type: :generation_completed, iteration: iteration, content_length: response.text.length,
+               thinking_chars: response.reasoning.to_s.length, served_model: response.model,
+               requested_model: @model_name, finish_reason: response.finish_reason)
+          dump_response(response, iteration)
+          @loop.fire_hook(:after_generation, { type: :after_generation, iteration: iteration, response: response.text,
+                                               messages: AnswerDisplay.strip_all(@conversation).map(&:dup).freeze })
+          [response, nil]
+        rescue RequestCancelled => e
+          [e.reason, streamed]
+        end
+
+        def request(iteration, retry_generation, streamed)
+          @loop.adapter.chat(
             messages: @loop.wire_messages(@conversation), tools: @loop.tool_definitions, model: @model_name,
             cancel_controller: @cancel_controller, session_id: @loop.session_id,
+            options: @loop.request_options(retry_generation: retry_generation, model: @model_name),
             on_delta: lambda { |content:, reasoning:, payload:|
               streamed << content
               emit(type: :generation_chunk, iteration: iteration, content: reasoning + content, text: content,
@@ -337,16 +446,13 @@ module Samagotchi
             },
             on_retry: ->(**retry_event) { emit({ type: :generation_retrying, iteration: iteration }.merge(retry_event)) }
           )
-          record_context_status(response.usage, window)
-          emit(type: :generation_completed, iteration: iteration, content_length: response.text.length,
-               thinking_chars: response.reasoning.to_s.length, served_model: response.model,
-               requested_model: @model_name)
-          dump_response(response, iteration)
-          @loop.fire_hook(:after_generation, { type: :after_generation, iteration: iteration, response: response.text,
-                                               messages: @conversation.map(&:dup).freeze })
-          [response, nil]
-        rescue RequestCancelled => e
-          [e.reason, streamed]
+        end
+
+        # A 400 about reasoning, for a request that carried thinking fields
+        # (not a missing-tools, image or context error).
+        def thinking_refused?(error)
+          error.reasoning_refused? && !error.is_a?(VisionUnsupported) && !error.tools_unsupported? &&
+            !error.context_overflow? && !@loop.thinking_fields(@model_name).empty?
         end
 
         # The status line's value from the server's counts for this request
@@ -385,31 +491,28 @@ module Samagotchi
             # A plugin tool's params line, for the web's reload; never sent.
             entry[:tool_params] = run[:shown_params] if run[:shown_params]
             entry[:tool_labels] = run[:shown_label] if run[:shown_label]
+            # What an edit/write changed, for the web's reload; never sent.
+            entry[:tool_diffs] = run[:diff] if run[:diff]
             @conversation << entry
           end
           emit(type: :tool_dispatch_completed, iteration: iteration, call_count: tool_calls.length)
         end
 
-        # Queued steering joins the conversation as one user message.
-        # Returns true when there was any. After a cancel it stays queued, so
-        # it runs as the next turn instead of dying with this one. +answer+ is
-        # the answer the merge follows, for the UIs.
+        # Queued steering joins the conversation as one user message, a
+        # plugin's steers each as its own after it (Steer). Returns true when
+        # there was any. After a cancel it stays queued, so it runs as the
+        # next turn instead of dying with this one. +answer+ is the answer the
+        # merge follows, for the UIs; given, the drain is told it is the
+        # after-answer site (plugin steers are dropped there).
         def inject_pending_input(iteration, answer: nil)
           return false unless @pending_input
           return false if @cancel_controller&.cancelled?
 
-          lines = begin
-            @pending_input.call
-          rescue StandardError
-            nil
-          end
-          return false if lines.nil? || lines.empty?
-
-          content = lines.map { |line| line.to_s.strip }.reject(&:empty?).join("\n\n")
-          return false if content.empty?
+          merge = Steer.merge(Steer.drain(@pending_input, at_answer: !answer.nil?))
+          return false if merge.empty?
 
-          @conversation << { role: "user", content: content }
-          emit(type: :pending_input_merged, iteration: iteration, count: lines.length, content: content,
+          @conversation.concat(merge.messages)
+          emit(type: :pending_input_merged, iteration: iteration, **merge.event_fields,
                answer: answer.to_s.empty? ? nil : answer)
           true
         end