samagotchi 0.3.0 → 0.5.0

data/lib/samagotchi/kernel_loop.rb

@@ -11,6 +11,7 @@ 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"
@@ -111,16 +112,10 @@ module Samagotchi
     CONTEXT_LINE_PREFIX = "[CONTEXT: "
     CONTEXT_LINE_KIND = "context"
     CONTEXT_GUIDANCE_FROM_RANK = 2
-    CONTEXT_STATUS_ENABLED_ENV = "SAMAGOTCHI_CONTEXT_STATUS"
-    CONTEXT_CHARS_PER_TOKEN_ENV = "SAMAGOTCHI_CONTEXT_CHARS_PER_TOKEN"
-    CONTEXT_THRESHOLDS_ENV = "SAMAGOTCHI_CONTEXT_STATUS_THRESHOLDS"
-    CONTEXT_CADENCE_ENV = "SAMAGOTCHI_CONTEXT_STATUS_CADENCE"
 
     DEFAULT_CONTEXT_CHARS_PER_TOKEN = 4.0
     DEFAULT_CONTEXT_THRESHOLDS = [20, 40, 60, 80].freeze
-    DEFAULT_CONTEXT_CADENCE = 0
     DEFAULT_MAX_TOOL_OUTPUT_CHARS = 10_000
-    TOOL_OUTPUT_CHARS_ENV = "SAMAGOTCHI_MAX_TOOL_OUTPUT_CHARS"
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_LIMIT = 2
     QWEN_INCOMPLETE_TOOL_CALL_RECOVERY_PROMPT = "Continue the previous assistant message by finishing the open <tool_call> XML block. Output only the remaining XML needed to complete the tool call."
 
@@ -179,6 +174,9 @@ module Samagotchi
     # 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
@@ -193,7 +191,7 @@ module Samagotchi
     # @param cancel_controller [CancellationController, nil] optional cancellation source
     # @param model_name [String, nil]            optional per-run model override
     # @param max_tool_output_chars [Integer, nil] per-output char cap for the
-    #   :tool_call_completed event's `output:` (nil → env/DEFAULT_MAX_TOOL_OUTPUT_CHARS)
+    #   :tool_call_completed event's `output:` (nil → max_tool_output_chars)
     # @param pending_input [#call, nil]  optional drain proc returning
     #   Array<String> of user steering messages queued while the turn runs.
     #   Drained at iteration boundaries (llama.cpp's /completion cannot accept
@@ -217,13 +215,17 @@ module Samagotchi
       @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,
@@ -232,7 +234,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,
@@ -294,6 +296,9 @@ module Samagotchi
             images: images
           )
         )
+        # What the server's prompt count covers, so the next estimate adds
+        # only what the turn appended since (answer, tool results).
+        context_state[:counted] = { chars: prompt.length, image_tokens: image_tokens } if generation_usage
         refresh_context_display(context_state, generation_usage, context_window)
         emit_stream_event(
           on_stream_event,
@@ -310,7 +315,7 @@ module Samagotchi
         after_gen_event = { type: :after_generation, iteration: iteration_index + 1, response: response,
                             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
@@ -365,6 +370,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,
@@ -374,6 +380,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)
@@ -387,6 +394,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
@@ -514,18 +524,13 @@ module Samagotchi
 
     # Resolve the per-output character cap for the emitted tool call events.
     #
-    # Precedence: an explicit override wins, then the SAMAGOTCHI_MAX_TOOL_OUTPUT_CHARS
-    # env var, then DEFAULT_MAX_TOOL_OUTPUT_CHARS. A non-positive value falls back
-    # to the default (there is intentionally no "unlimited" — live UIs get a
+    # Precedence: an explicit override wins, then max_tool_output_chars
+    # (Config). A non-positive value falls back to
+    # DEFAULT_MAX_TOOL_OUTPUT_CHARS (there is intentionally no "unlimited" — live UIs get a
     # bounded `output:` plus a truthful `output_truncated:` flag).
     # Class-level so the chat loop resolves it the same way.
     def self.resolve_output_char_cap(override)
-      cfg_val = begin
-        v = Samagotchi::Config.get("max_tool_output_chars") rescue nil
-        v.to_i if v
-      end
-      value = override || cfg_val || ENV[TOOL_OUTPUT_CHARS_ENV]
-      parsed = value.to_i
+      parsed = (override || Samagotchi::Config.get("max_tool_output_chars")).to_i
       parsed.positive? ? parsed : DEFAULT_MAX_TOOL_OUTPUT_CHARS
     end
 
@@ -552,8 +557,8 @@ module Samagotchi
     end
 
     def completion_n_predict
-      v = Samagotchi::Config.get("default.n_predict") rescue nil
-      v.to_i if v && v.to_i.positive?
+      value = Samagotchi::Config.get("default.n_predict").to_i
+      value if value.positive?
     end
 
     def completion_model_name(override = nil)
@@ -612,7 +617,8 @@ module Samagotchi
     def emit_context_status_event(on_stream_event, prompt, iteration_index:, state:, window: nil, image_tokens: 0)
       return nil unless context_status_enabled?
 
-      usage = estimate_context_usage(prompt, server_usage: state[:server_usage], window: window, image_tokens: image_tokens)
+      usage = estimate_context_usage(prompt, server_usage: state[:server_usage], window: window, image_tokens: image_tokens,
+                                             counted: state[:counted])
       bucket = context_status_bucket(usage[:estimated_pct])
       # The status line's value, every iteration; the gate below decides
       # only the event and the model's guidance line.
@@ -674,20 +680,18 @@ module Samagotchi
     end
 
     def context_status_enabled?
-      cfg = begin Samagotchi::Config.get("context.status") rescue nil end
-      unless cfg.nil?
-        return !!cfg
-      end
-      value = ENV[CONTEXT_STATUS_ENABLED_ENV]
-      return true if value.nil?
-
-      !(value == "0" || value.casecmp?("false"))
+      Samagotchi::Config.get("context.status") != false
     end
 
     # `window` is this iteration's ContextWindow::Resolved (resolved here when
     # not given). A window the stream payload reports itself still wins.
     # +image_tokens+: the images' estimate (their base64 is not in +prompt+).
-    def estimate_context_usage(prompt, server_usage: nil, window: nil, image_tokens: 0)
+    # +counted+: the prompt the server's prompt_tokens counted ({chars:,
+    # image_tokens:}); what +prompt+ has on top of it (the answer, tool
+    # results since) is added as an estimate, so the value doesn't read low
+    # during a long tool loop. A prompt shorter than that one (trimmed) or
+    # none known: the server's count alone.
+    def estimate_context_usage(prompt, server_usage: nil, window: nil, image_tokens: 0, counted: nil)
       window ||= ContextWindow.resolve(client: @client, model: @current_model_name)
       window_source = window.source
       if server_usage && server_usage[:context_window_tokens]
@@ -696,7 +700,7 @@ module Samagotchi
 
       if server_usage && server_usage[:prompt_tokens]
         window_tokens = server_usage[:context_window_tokens] || window.tokens
-        estimated_used_tokens = server_usage[:prompt_tokens]
+        estimated_used_tokens = server_usage[:prompt_tokens] + appended_tokens(prompt, image_tokens, counted)
         estimated_remaining_tokens = [window_tokens - estimated_used_tokens, 0].max
         estimated_pct = (estimated_used_tokens.to_f / window_tokens) * 100.0
 
@@ -725,31 +729,29 @@ module Samagotchi
       }
     end
 
+    # The estimate for what +prompt+ added since the +counted+ one.
+    def appended_tokens(prompt, image_tokens, counted)
+      return 0 unless counted
+
+      chars = prompt.length - counted[:chars]
+      return 0 unless chars.positive?
+
+      (chars / context_chars_per_token).ceil + [image_tokens - counted[:image_tokens].to_i, 0].max
+    end
+
     def context_chars_per_token
-      cfg = begin Samagotchi::Config.get("context.chars_per_token") rescue nil end
-      if cfg && cfg.to_f.positive?
-        v = cfg.to_f
-        return v.positive? ? v : DEFAULT_CONTEXT_CHARS_PER_TOKEN
-      end
-      value = ENV.fetch(CONTEXT_CHARS_PER_TOKEN_ENV, DEFAULT_CONTEXT_CHARS_PER_TOKEN.to_s).to_f
+      value = Samagotchi::Config.get("context.chars_per_token").to_f
       value.positive? ? value : DEFAULT_CONTEXT_CHARS_PER_TOKEN
     end
 
     def context_status_thresholds
-      cfg = begin Samagotchi::Config.get("context.status_thresholds") rescue nil end
-      raw = cfg && !cfg.to_s.strip.empty? ? cfg.to_s : ENV.fetch(CONTEXT_THRESHOLDS_ENV, DEFAULT_CONTEXT_THRESHOLDS.join(","))
+      raw = Samagotchi::Config.get("context.status_thresholds").to_s
       parsed = raw.split(",").map { |value| value.strip.to_i }.select { |value| value.between?(1, 99) }.uniq.sort
       parsed.empty? ? DEFAULT_CONTEXT_THRESHOLDS : parsed
     end
 
     def context_status_cadence
-      cfg = begin Samagotchi::Config.get("context.status_cadence") rescue nil end
-      if !cfg.nil?
-        v = cfg.to_i
-        return [v, 0].max
-      end
-      value = ENV.fetch(CONTEXT_CADENCE_ENV, DEFAULT_CONTEXT_CADENCE.to_s).to_i
-      [value, 0].max
+      [Samagotchi::Config.get("context.status_cadence").to_i, 0].max
     end
 
     # 0 for the bucket under the first threshold, then one per threshold.
@@ -828,14 +830,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
@@ -974,76 +968,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
+      payload = Samagotchi::Tools::AskUserQuestion.validate(call)
+      return payload if payload.is_a?(String)
+      return JSON.pretty_generate(payload) unless @question_handler
 
-      # 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)
-
-      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,65 @@
+# 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)
+      web_info(host, port, timeout: timeout)&.fetch("version", nil).to_s.then { |v| v.empty? ? nil : v }
+    end
+
+    # The /api/info of a chi web on host:port, or nil when nothing (or not
+    # chi web) answers.
+    def web_info(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 : 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

@@ -17,6 +17,7 @@ require_relative "../vision_context"
 require_relative "../log"
 require_relative "../empty_answer_retry"
 require_relative "../turn_note"
+require_relative "../thinking"
 
 module Samagotchi
   module LLM
@@ -139,6 +140,34 @@ module Samagotchi
         @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
@@ -180,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
@@ -191,6 +220,7 @@ 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
@@ -199,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)
@@ -364,23 +406,22 @@ module Samagotchi
         # text] when it was cancelled.
         def generate(iteration)
           window = @window = @loop.context_window(@model_name)
-          options = @loop.sampling
-          options = EmptyAnswerRetry.sampling(options) if @retry_generation
+          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(
-            messages: @loop.wire_messages(@conversation), tools: @loop.tool_definitions, model: @model_name,
-            cancel_controller: @cancel_controller, session_id: @loop.session_id, options: options,
-            on_delta: lambda { |content:, reasoning:, payload:|
-              streamed << content
-              emit(type: :generation_chunk, iteration: iteration, content: reasoning + content, text: content,
-                   thinking: reasoning, payload: payload)
-            },
-            on_retry: ->(**retry_event) { emit({ type: :generation_retrying, iteration: iteration }.merge(retry_event)) }
-          )
+          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,
@@ -393,6 +434,27 @@ module Samagotchi
           [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,
+                   thinking: reasoning, payload: payload)
+            },
+            on_retry: ->(**retry_event) { emit({ type: :generation_retrying, iteration: iteration }.merge(retry_event)) }
+          )
+        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
         # (prompt + answer); without them the last value stays.
         def record_context_status(usage, window)
@@ -429,6 +491,8 @@ 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)