samagotchi 0.22.0 → 0.24.0

data/lib/samagotchi/idle_reminders.rb

@@ -46,6 +46,7 @@ module Samagotchi
     def should_check?
       return false if @engine.turn_running?
       return false unless last_idle_seconds >= @inactivity
+
       true
     end
 
@@ -57,15 +58,17 @@ module Samagotchi
 
     def check_due_reminders
       return unless @queue
+
       due_names = @queue.due.map { |r| r[:name] }
       return if due_names.empty?
+
       # Signal the engine to create a synthetic turn via callback.
       # The callback is responsible for triggering a turn (e.g. SessionManager
       # writes a file, TerminalUI queues input). The engine's run_turn or
       # REPL injection point then picks up and delivers the reminders.
-      if @auto_turn_callback
-        @auto_turn_callback.call(due_names)
-      end
+      return unless @auto_turn_callback
+
+      @auto_turn_callback.call(due_names)
     end
   end
 end

data/lib/samagotchi/image_store.rb

@@ -100,7 +100,8 @@ module Samagotchi
   # Downscales and converts images with whatever tool the machine has:
   # macOS sips first, then ImageMagick. `none` when neither is installed.
   class ImageResizer
-    Error = Class.new(StandardError)
+    class Error < StandardError
+    end
 
     attr_reader :tool
 
@@ -191,7 +192,8 @@ module Samagotchi
   # Messages hold small refs to those files; the base64 is built only when
   # a request is sent.
   module ImageStore
-    Error = Class.new(StandardError)
+    class Error < StandardError
+    end
 
     DIR = "images"
     REF_RE = %r{\Aimages/[0-9a-f]{16}\.(png|jpe?g|gif|webp)\z}
@@ -234,6 +236,7 @@ module Samagotchi
 
       name = (name || (path && File.basename(path)) || "image").to_s
       raise Error, "#{name} is too large (over 50 MB)" if bytes.bytesize > MAX_SOURCE_BYTES
+
       info = ImageHeader.read(bytes)
       raise Error, "#{name} is not an image chi can send (png, jpeg, gif, webp)" unless info
 

data/lib/samagotchi/kernel_loop.rb

@@ -134,8 +134,7 @@ module Samagotchi
     # @return [Tools::Registry] the tools #dispatch runs. The Engine sets
     #   its own on a kernel it is given, as with hooks.
     attr_accessor :tools
-    attr_accessor :client
-    attr_accessor :model_key
+    attr_accessor :client, :model_key
     # @return [String, nil] the key whose overlay memory_read takes when
     #   #model_key has none (#sync_model_key!)
     attr_reader :model_key_fallback
@@ -210,6 +209,18 @@ module Samagotchi
       @model_key_fallback = fallback
     end
 
+    # Resolve the per-output character cap for the emitted tool call events.
+    #
+    # 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)
+      parsed = (override || Samagotchi::Config.get("max_tool_output_chars")).to_i
+      parsed.positive? ? parsed : DEFAULT_MAX_TOOL_OUTPUT_CHARS
+    end
+
     private
 
     # ── One turn (#run) ────────────────────────────────────────────────────────
@@ -223,7 +234,7 @@ module Samagotchi
                       :cancel_controller, :cap, :emit, :iteration, :empty_steps, :ended_empty, keyword_init: true)
     # One request: the prompt and its images as sent, the images' token
     # estimate, and the window it was measured against.
-    Request = Struct.new(:prompt, :images, :image_tokens, :window, keyword_init: true)
+    Request = Struct.new(:prompt, :images, :image_tokens, :window, :prefill, keyword_init: true)
     # One generation: the response (nil when cut), the cut's detail, this
     # generation's own server counts, the model the server named, the
     # thinking it streamed, and why it stopped (the transport's finish
@@ -254,7 +265,7 @@ module Samagotchi
       generation = generate(turn, request)
       return after_cut(turn, generation) if generation.cut
 
-      turn.conversation << { role: "model", content: turn.prefill + generation.response.to_s }
+      turn.conversation << { role: "model", content: request.prefill + generation.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
       # iteration if the model opened a tool-call block it did not close.
@@ -279,7 +290,10 @@ module Samagotchi
         turn.conversation << line
         prompt, images = format_prompt(turn)
       end
-      Request.new(prompt: prompt, images: images, image_tokens: image_tokens, window: window)
+      # The prefill the prompt ended with (none where Gemma's turn goes on
+      # after a tool response): the model message keeps it.
+      prefill = Prompt.prefill_for(turn.conversation, @profile, turn.prefill)
+      Request.new(prompt: prompt, images: images, image_tokens: image_tokens, window: window, prefill: prefill)
     end
 
     def format_prompt(turn)
@@ -341,8 +355,12 @@ module Samagotchi
       generation.streamed_thinking += split[:thinking].to_s.length
       return unless turn.on_stream_event
 
-      emit(turn, type: :generation_chunk, iteration: turn.iteration, content: chunk[:content], text: split[:text],
-                 thinking: split[:thinking], payload: chunk[:payload])
+      event = { type: :generation_chunk, iteration: turn.iteration, content: chunk[:content], text: split[:text],
+                thinking: split[:thinking], payload: chunk[:payload] }
+      # A chunk of a tool call (its bytes are dropped from both lanes): a
+      # steer doesn't cut this generation (Engine#cut_for_steer).
+      event[:tool_call] = true if split[:tool]
+      emit(turn, **event)
     end
 
     # The cut stream's visible text goes with it: the buffer as it was
@@ -372,18 +390,24 @@ module Samagotchi
                                      messages: AnswerDisplay.strip_all(turn.conversation).map(&:dup).freeze })
     end
 
-    # A generation a plugin cut is an empty answer made early: asked again
-    # 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.
+    # A generation a plugin cut is an empty answer made early. Queued input
+    # (a user's line, a plugin's steer) goes in first, with or without a
+    # retry left, and spends no attempt: the model answers it. A steer's cut
+    # (Engine#cut_for_steer) with nothing queued (its message was taken at
+    # a boundary already) is asked again as is. Else it is asked again with
+    # its own nudge while the retry budget lasts, 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.
     def after_cut(turn, generation)
       cut = generation.cut
-      raise Client::RequestCancelled.new(turn.cancel_controller.reason) if turn.cancel_controller.cancelled?
+      raise Client::RequestCancelled, turn.cancel_controller.reason if turn.cancel_controller.cancelled?
 
-      if turn.empty_retry.left?
-        return :next if inject_pending_input!(turn)
+      # The row under the cut step, above the message it was cut for.
+      emit(turn, type: :steer_cut, iteration: turn.iteration, source: cut[:source].to_s) if cut[:steer]
+      return :next if inject_pending_input!(turn) || cut[:steer]
 
+      if turn.empty_retry.left?
         turn.empty_retry.nudge!(turn.conversation, TurnNote.cut_retry(cut[:by], cut[:reason]),
                                 emit: turn.emit, iteration: turn.iteration, finish_reason: "stopped",
                                 thinking_chars: generation.streamed_thinking, stopped_by: cut[:by])
@@ -493,7 +517,6 @@ module Samagotchi
       nil
     end
 
-
     # ── Hook dispatch helper ───────────────────────────────────────────────────
 
     # Fire a named hook on the registry (if present).
@@ -505,6 +528,7 @@ module Samagotchi
 
     def fire_hook(name, event)
       return unless @hooks
+
       @hooks.fire(name, event)
     rescue StandardError
       # A failing hook must not break the turn.
@@ -517,34 +541,22 @@ module Samagotchi
 
     # ── Output char cap resolution ─────────────────────────────────────────────
 
-    # Resolve the per-output character cap for the emitted tool call events.
-    #
-    # 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)
-      parsed = (override || Samagotchi::Config.get("max_tool_output_chars")).to_i
-      parsed.positive? ? parsed : DEFAULT_MAX_TOOL_OUTPUT_CHARS
-    end
-
     def resolve_output_char_cap(override)
       self.class.resolve_output_char_cap(override)
     end
 
     # One request, cancelled by +generation_controller+ (the turn's child)
     # when there is one.
-    def request_generation(prompt, generation_controller:, cancel_controller:, **options)
-      @client.complete(prompt, **complete_kwargs(cancel_controller: generation_controller || cancel_controller, **options))
+    def request_generation(prompt, generation_controller:, cancel_controller:, **)
+      @client.complete(prompt, **complete_kwargs(cancel_controller: generation_controller || cancel_controller, **))
     end
 
     # Yields the turn controller's child for one generation (nil without a
     # controller).
-    def with_generation(cancel_controller, &block)
+    def with_generation(cancel_controller, &)
       return yield(nil) unless cancel_controller
 
-      cancel_controller.generation(&block)
+      cancel_controller.generation(&)
     end
 
     # The generation was cut (stop_generation) and the turn goes on.
@@ -561,19 +573,14 @@ module Samagotchi
       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
+      max_tokens = Samagotchi::Config.max_tokens
+      kwargs[:n_predict] = max_tokens if max_tokens
       resolved_model_name = completion_model_name(model_name)
       kwargs[:model] = resolved_model_name if resolved_model_name
       kwargs[:sampling] = sampling if sampling && !sampling.empty?
       kwargs
     end
 
-    def completion_n_predict
-      value = Samagotchi::Config.get("default.n_predict").to_i
-      value if value.positive?
-    end
-
     def completion_model_name(override = nil)
       ModelProfile.required_model_name(override)
     end
@@ -635,6 +642,7 @@ module Samagotchi
       @parser_profile = @profile
       @parser
     end
+
     private
 
     # The generation's thinking: what the stream split into the thinking
@@ -682,6 +690,7 @@ module Samagotchi
     end
 
     public
+
     # Public entry point for executing an ALREADY-NORMALIZED internal tool call
     # (the {name:, content:, path:, scope:, …} shape).
     #
@@ -696,6 +705,7 @@ module Samagotchi
     end
 
     private
+
     def dispatch(call)
       entry = @tools[call[:name]]
       unless entry
@@ -723,7 +733,7 @@ module Samagotchi
         dispatched[:image_only] = true if result.respond_to?(:image_only?) && result.image_only?
       end
       dispatched
-    rescue => e
+    rescue StandardError => e
       dump_log("tool_error", e.message, tool: call[:name], error: e.class.name)
       result = "Error: #{e.message}"
       {

data/lib/samagotchi/llm/chat_loop.rb

@@ -107,7 +107,9 @@ module Samagotchi
           when "system"
             wire << { role: "system", content: entry[:content].to_s }
           when "user"
-            wire << { role: "user", content: parts(entry[:content], items) }
+            # A steer or merged input (always a String) goes with its header.
+            content = Steer.header(entry) ? Steer.wire_text(entry, entry[:content].to_s) : entry[:content]
+            wire << { role: "user", content: parts(content, items) }
           when "model"
             wire << assistant_message(entry, paired)
           when "tool_response"
@@ -155,12 +157,15 @@ module Samagotchi
         (@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").
+      # One generation's options: default.max_tokens as max_tokens (the
+      # adapter's own default, OpenRouter's, otherwise), 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)
+        max_tokens = Samagotchi::Config.max_tokens
         options = deep_merge(thinking_fields(model), sampling)
+        options = { max_tokens: max_tokens }.merge(options) if max_tokens
         options = EmptyAnswerRetry.sampling(options) if retry_generation
         deep_compact(options)
       end
@@ -378,17 +383,22 @@ module Samagotchi
         end
 
         # A generation a plugin cut (stop_generation) is an empty answer made
-        # early: asked again 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 a spent nudge.
-        # A Stop that came right after the cut is a plain cancel. Returns
-        # :retry, or the turn's result.
+        # early. Queued input (a user's line, a plugin's steer) goes in
+        # first, with or without a retry left, and spends no attempt. A
+        # steer's cut (Engine#cut_for_steer) with nothing queued is asked
+        # again as is. Else it is asked again with its own nudge while the
+        # retry budget lasts, else the turn ends as cancelled (hook), with
+        # nothing salvaged and without a spent nudge. A Stop that came right
+        # after the cut is a plain cancel. Returns :retry, or the turn's
+        # result.
         def after_cut(iteration, response)
           return canceled(iteration, @cancel_controller.reason) if @cancel_controller.cancelled?
 
-          if @empty_retry.left?
-            return :retry if inject_pending_input(iteration)
+          # The row under the cut step, above the message it was cut for.
+          emit(type: :steer_cut, iteration: iteration, source: response.cut[:source].to_s) if response.cut[:steer]
+          return :retry if inject_pending_input(iteration) || response.cut[:steer]
 
+          if @empty_retry.left?
             @empty_retry.nudge!(@conversation, TurnNote.cut_retry(response.cut[:by], response.cut[:reason]),
                                 emit: method(:emit), iteration: iteration, finish_reason: response.finish_reason,
                                 thinking_chars: response.reasoning.to_s.length, stopped_by: response.cut[:by])
@@ -449,10 +459,10 @@ module Samagotchi
 
         # The request runs under the generation's own controller (the turn
         # controller's child), so a plugin's stop_generation cuts it alone.
-        def with_generation(&block)
+        def with_generation(&)
           return yield(nil) unless @cancel_controller
 
-          @cancel_controller.generation(&block)
+          @cancel_controller.generation(&)
         end
 
         # The empty response of a cut generation: its spinners close as any
@@ -475,8 +485,11 @@ module Samagotchi
             on_delta: lambda { |content:, reasoning:, payload:|
               streamed << content
               thought << reasoning
-              emit(type: :generation_chunk, iteration: iteration, content: reasoning + content, text: content,
-                   thinking: reasoning, payload: payload)
+              event = { type: :generation_chunk, iteration: iteration, content: reasoning + content, text: content,
+                        thinking: reasoning, payload: payload }
+              # A tool call streaming: a steer doesn't cut it (Engine#cut_for_steer).
+              event[:tool_call] = true if OpenAIChat.tool_call_delta?(payload)
+              emit(event)
             },
             on_retry: ->(**retry_event) { emit({ type: :generation_retrying, iteration: iteration }.merge(retry_event)) }
           )

data/lib/samagotchi/llm/errors.rb

@@ -125,12 +125,12 @@ module Samagotchi
 
       # @param hint [String, nil] what to try, added to the summary
       def initialize(message = nil, context_overflow: false, tools_unsupported: false, reasoning_refused: false, hint: nil,
-                     **options)
+                     **)
         @context_overflow = context_overflow
         @tools_unsupported = tools_unsupported
         @reasoning_refused = reasoning_refused
         @hint = hint
-        super(message, **options)
+        super(message, **)
       end
 
       attr_reader :hint

data/lib/samagotchi/llm/http.rb

@@ -138,7 +138,7 @@ module Samagotchi
         end
       end
 
-      def stream_attempt(uri, request, current, &on_line)
+      def stream_attempt(uri, request, current, &)
         # Time to first token is the answering attempt's, not the retries'.
         current[:attempt_started_at] = monotonic_now
         shown = lambda do
@@ -155,11 +155,11 @@ module Samagotchi
               response.read_body do |chunk|
                 buffer << chunk
                 while (newline_index = buffer.index("\n"))
-                  on_line.call(buffer.slice!(0, newline_index + 1).strip, shown)
+                  yield(buffer.slice!(0, newline_index + 1).strip, shown)
                 end
               end
               # A body that doesn't end in a newline still has a last line.
-              on_line.call(buffer.strip, shown) unless buffer.strip.empty?
+              yield(buffer.strip, shown) unless buffer.strip.empty?
             end
           end
         end
@@ -192,7 +192,7 @@ module Samagotchi
           cancellable(cancel_controller, current) do
             attempt.call(current.merge!(attempts: 1))
           rescue StandardError => e
-            raise RequestCancelled.new(cancel_controller.reason) if !e.is_a?(RequestCancelled) && cancel_controller&.cancelled?
+            raise RequestCancelled, cancel_controller.reason if !e.is_a?(RequestCancelled) && cancel_controller&.cancelled?
 
             raise
           end
@@ -208,7 +208,7 @@ module Samagotchi
         @api_key&.authorize(request)
       end
 
-      def start(uri, open_timeout: nil, read_timeout: nil, max_retries: nil, &block)
+      def start(uri, open_timeout: nil, read_timeout: nil, max_retries: nil, &)
         options = { open_timeout: open_timeout || @open_timeout, read_timeout: read_timeout || @read_timeout }
         # Net::HTTP retries an idempotent request once on its own (max_retries
         # defaults to 1) when the connection drops before an answer: chi's
@@ -218,15 +218,15 @@ module Samagotchi
         retries = max_retries || 0
         options[:max_retries] = retries
         options[:use_ssl] = true if uri.scheme == "https"
-        Net::HTTP.start(uri.host, uri.port, **options, &block)
+        Net::HTTP.start(uri.host, uri.port, **options, &)
       end
 
       # Runs the block (one attempt) until it returns, retrying network
       # errors. The block gets a hash to put the attempt's Net::HTTP in, so a
       # cancel can reach its socket.
-      def with_retries(cancel_controller, on_retry, on_network_error, current = { mutex: Mutex.new })
+      def with_retries(cancel_controller, on_retry, on_network_error, current = { mutex: Mutex.new }, &block)
         cancellable(cancel_controller, current) do
-          retrying(cancel_controller, on_retry, on_network_error, current) { |state| yield(state) }
+          retrying(cancel_controller, on_retry, on_network_error, current, &block)
         end
       end
 
@@ -236,7 +236,7 @@ module Samagotchi
       def cancellable(cancel_controller, current)
         requesting_thread = Thread.current
         listener_id = cancel_controller&.on_cancel { |reason| abort_request(current, requesting_thread, reason) }
-        raise RequestCancelled.new(cancel_controller.reason) if cancel_controller&.cancelled?
+        raise RequestCancelled, cancel_controller.reason if cancel_controller&.cancelled?
 
         yield
       ensure
@@ -257,7 +257,7 @@ module Samagotchi
           rescue RequestCancelled
             raise
           rescue ProviderError => e
-            raise RequestCancelled.new(cancel_controller.reason) if cancel_controller&.cancelled?
+            raise RequestCancelled, cancel_controller.reason if cancel_controller&.cancelled?
 
             e.attempts = attempts
             raise if !e.retryable? || current[:streamed]
@@ -267,7 +267,7 @@ module Samagotchi
 
             retry_after(e, attempts, delay, on_retry, cancel_controller, current)
           rescue StandardError => e
-            raise RequestCancelled.new(cancel_controller.reason) if cancel_controller&.cancelled?
+            raise RequestCancelled, cancel_controller.reason if cancel_controller&.cancelled?
             raise first_token_timeout if current[:first_token_expired]
             raise unless self.class.network_error?(e)
 
@@ -432,7 +432,7 @@ module Samagotchi
 
         remaining = seconds
         while remaining.positive?
-          raise RequestCancelled.new(cancel_controller.reason) if cancel_controller.cancelled?
+          raise RequestCancelled, cancel_controller.reason if cancel_controller.cancelled?
 
           slice = [remaining, WAIT_TICK].min
           @sleeper.call(slice)

data/lib/samagotchi/llm/openai_chat.rb

@@ -53,13 +53,31 @@ module Samagotchi
       # How much of a 200's non-stream body is read as a possible JSON error.
       PLAIN_ERROR_LIMIT = 64 * 1024
       DEFAULT_MODELS_TTL = 60
+      # OpenRouter holds a paid request's estimated cost against the balance
+      # while it runs: the input plus the output max_tokens allows (a fixed
+      # per-request cap when it is unset), and refuses a request with a 402
+      # once the running ones fill the budget. A request that names a sane
+      # limit holds less. 32k leaves room for any one step's answer.
+      OPENROUTER_MAX_TOKENS = 32_768
 
-      attr_reader :base_url, :host_name, :api_key_env, :models_ttl, :first_token_timeout
+      attr_reader :base_url, :host_name, :api_key_env, :models_ttl, :first_token_timeout, :default_max_tokens
 
       # @param entry [HostRegistry::HostEntry]
-      def self.for(entry, **options)
+      def self.for(entry, **)
         new(base_url: entry.openai_base_url, host_name: entry.name, api_key_env: entry.api_key_env,
-            remote: entry.remote?, **options)
+            remote: entry.remote?, default_max_tokens: (OPENROUTER_MAX_TOKENS if openrouter?(entry.openai_base_url)),
+            **)
+      end
+
+      # true when a streamed +payload+ carries a tool-call delta.
+      def self.tool_call_delta?(payload) = Assembly.tool_call_delta?(payload)
+
+      # true when +url+ is OpenRouter's API (openrouter.ai or a subdomain).
+      def self.openrouter?(url)
+        host = URI(url.to_s).host.to_s.downcase
+        host == "openrouter.ai" || host.end_with?(".openrouter.ai")
+      rescue URI::Error
+        false
       end
 
       # Tool arguments as a Hash; "" is {}, invalid JSON stays a String.
@@ -87,10 +105,13 @@ module Samagotchi
       # @param remote [Boolean] a provider on the network, not a local server
       # @param first_token_timeout [Numeric, nil] seconds a streamed answer
       #   may take to show something (LLM::HTTP); nil: no limit
+      # @param default_max_tokens [Integer, nil] max_tokens for a request
+      #   whose options name none (OPENROUTER_MAX_TOKENS); nil sends none
       def initialize(base_url:, host_name:, api_key_env: nil, stream: true, retries: true, timeout: nil,
                      env: ENV, sleeper: nil, retry_policy: nil, models_ttl: DEFAULT_MODELS_TTL, remote: false,
-                     first_token_timeout: nil, purpose: "chat")
+                     first_token_timeout: nil, purpose: "chat", default_max_tokens: nil)
         @remote = remote
+        @default_max_tokens = default_max_tokens
         # What its requests are for, in the log (LLM::HTTP::LOGGED_PURPOSES).
         @purpose = purpose
         @first_token_timeout = first_token_timeout
@@ -163,7 +184,7 @@ module Samagotchi
         models = []
         after = nil
         MAX_MODEL_PAGES.times do
-          uri = URI("#{@base_url}/models#{after ? "?after=#{URI.encode_www_form_component(after)}" : ""}")
+          uri = URI("#{@base_url}/models#{"?after=#{URI.encode_www_form_component(after)}" if after}")
           body = parse_json(@http.fetch(uri, get_request(uri), log_fields: { purpose: "models" }).body, "model list")
           models.concat(model_entries(body).map { |raw| model_info(raw) })
           break unless body.is_a?(Hash) && body["has_more"] && body["last_id"]
@@ -193,6 +214,18 @@ module Samagotchi
         nil
       end
 
+      def self.served_model(payload)
+        model = payload.is_a?(Hash) ? payload["model"] : nil
+        model.is_a?(String) && !model.strip.empty? ? model : nil
+      end
+
+      # OpenRouter names the provider that served a request (Baseten,
+      # Fireworks, …) in the body's `provider`; other servers send none.
+      def self.served_provider(payload)
+        provider = payload.is_a?(Hash) ? payload["provider"] : nil
+        provider.is_a?(String) && !provider.strip.empty? ? provider : nil
+      end
+
       private
 
       def timeouts(timeout)
@@ -211,11 +244,12 @@ module Samagotchi
           stream: @stream
         }
         body[:stream_options] = { include_usage: true } if @stream
+        body[:max_tokens] = @default_max_tokens if @default_max_tokens
         unless Array(tools).empty?
           body[:tools] = tools
           body[:tool_choice] = "auto"
         end
-        # A configured value replaces chi's own (temperature); nil drops it.
+        # A configured value replaces chi's own (temperature, max_tokens); nil drops it.
         body.merge(options || {}).compact
       end
 
@@ -259,34 +293,15 @@ 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: OpenAIChat.drop_leading_newlines(message["content"].to_s),
+        ChatResponse.new(text: 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),
                          provider: self.class.served_provider(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
-      end
-
       def served_model(payload) = self.class.served_model(payload)
 
-      # OpenRouter names the provider that served a request (Baseten,
-      # Fireworks, …) in the body's `provider`; other servers send none.
-      def self.served_provider(payload)
-        provider = payload.is_a?(Hash) ? payload["provider"] : nil
-        provider.is_a?(String) && !provider.strip.empty? ? provider : nil
-      end
-
       def served_provider(payload) = self.class.served_provider(payload)
 
       # The parsed payload of a `data:` line; nil for blank lines, comments
@@ -357,7 +372,7 @@ module Samagotchi
         listed = raw["supported_parameters"] || raw["capabilities"]
         return nil unless listed.is_a?(Array)
 
-        listed.include?("tools") ? true : nil
+        listed.include?("tools") || nil
       end
 
       def cached_models
@@ -405,7 +420,6 @@ 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/prompt_cache.rb

@@ -55,7 +55,7 @@ module Samagotchi
       def content?(content)
         case content
         when String then !content.empty?
-        when Array then content.any? { |part| part.is_a?(Hash) }
+        when Array then content.any?(Hash)
         else false
         end
       end

data/lib/samagotchi/log.rb

@@ -143,7 +143,7 @@ module Samagotchi
       def safe_value(key, value)
         return "[redacted]" if key.match?(SECRET_KEY)
 
-        value = value.is_a?(Float) ? value.round(3) : value
+        value = value.round(3) if value.is_a?(Float)
         value.is_a?(String) && value.match?(URL) ? safe_url(value) : value
       end
 
@@ -185,7 +185,7 @@ module Samagotchi
       def build_state
         options = @options
         path = options.fetch(:path, :auto)
-        path = (LogPath.resolve rescue nil) if path == :auto
+        path = LogPath.resolve rescue nil if path == :auto
         level = options[:level] || (Config.get("log.level") rescue nil)
         level = LEVELS.key?(level.to_s.downcase.to_sym) ? level.to_s.downcase.to_sym : DEFAULT_LEVEL
         { writer: DebugLog.new(path: path), level: LEVELS.fetch(level), mirror: options[:mirror] ? true : false }