samagotchi 0.22.0 → 0.23.0

data/lib/samagotchi/hooks/bundle_loader.rb

@@ -65,13 +65,13 @@ module Samagotchi
             next if basename.empty?
 
             meta = ->(key) { raw_meta && (raw_meta[key] || raw_meta[key.to_s]) }
-            event = meta.(:event).to_s
+            event = meta.call(:event).to_s
             # A hook with no declared event cannot be auto-registered.
             next if event.empty?
 
             event_sym = event.to_sym
-            on_error = (meta.(:on_error) || "skip").to_s
-            priority = (meta.(:priority) || 100).to_i
+            on_error = (meta.call(:on_error) || "skip").to_s
+            priority = (meta.call(:priority) || 100).to_i
             fail_closed = on_error == "fail_closed" && event_sym == :before_tool_call
             what = "hook #{basename} (bundle #{bundle_name})"
             file = hooks_dir && File.join(hooks_dir, basename)
@@ -79,7 +79,7 @@ module Samagotchi
               failures&.add(what, "the file is missing", required: true) if fail_closed
               next
             end
-            if (mismatch = too_old || sha_mismatch(file, meta.(:sha256), required: fail_closed))
+            if (mismatch = too_old || sha_mismatch(file, meta.call(:sha256), required: fail_closed))
               Log.warn(:hooks, "bundle_hook_mismatch", echo: "[samagotchi:hooks] bundle '#{bundle_name}' hook '#{basename}' not loaded: #{mismatch}", bundle: bundle_name, hook: basename.to_s)
               failures&.add(what, mismatch, required: fail_closed)
               next
@@ -91,12 +91,14 @@ module Samagotchi
                        elsif on_error == "log" then :log
                        else :skip
                        end
-              label = "#{fail_closed ? "guardrail " : ""}#{basename} (bundle #{bundle_name})"
+              label = "#{"guardrail " if fail_closed}#{basename} (bundle #{bundle_name})"
               handler = Hooks.wrap(label: label, event: event_sym, policy: policy, log: [:hooks, "bundle_hook_failed"],
                                    fields: { bundle: bundle_name }) { |event| plugin.call(event) }
               registry.register_bundle(bundle_name, event_sym, hook_name: basename, priority: priority, &handler)
               loaded += 1
-            rescue Exception => e
+            rescue Exception => e # rubocop:disable Lint/RescueException -- a hook's SyntaxError or exit must not stop chi
+              raise if e.is_a?(SignalException) # Ctrl-C and kill signals are the user's
+
               Log.error(:hooks, "bundle_hook_load_failed", echo: "[samagotchi:hooks] bundle '#{bundle_name}' hook '#{basename}' failed to load: #{e.class}: #{e.message}", bundle: bundle_name, hook: basename.to_s, error: e.class.name)
               failures&.add(what, "#{e.class}: #{e.message}", required: fail_closed)
             end
@@ -127,6 +129,7 @@ module Samagotchi
           klass = Hooks.class_for(basename, ns)
           instance = Hooks.build_plugin(klass, settings)
           raise ArgumentError, "plugin #{klass.name.split("::").last} does not respond to #call" unless instance.respond_to?(:call)
+
           instance
         end
 

data/lib/samagotchi/hooks/loader.rb

@@ -67,17 +67,15 @@ module Samagotchi
           definitions = parse_definitions(hooks_config)
 
           definitions.each do |defn|
-            begin
-              plugin = load_plugin(hooks_dir, defn[:path], settings: defn[:settings])
-              # Persistent: config hooks must fire on every turn, not be wiped
-              # by Engine#run_turn's per-turn clear_hooks after turn 1.
-              registry.register_persistent(defn[:event_type].to_sym, label: "#{defn[:path]} (config)",
-                                           &wrapped(plugin, defn))
-            rescue ScriptError, StandardError => e
-              # ScriptError: a SyntaxError (or LoadError) from `require`.
-              Log.error(:hooks, "hook_load_failed", echo: "[samagotchi:hooks] hook #{defn[:path]} failed to load: #{e.class}: #{e.message}", hook: defn[:path].to_s, error: e.class.name)
-              failures&.add("hook #{defn[:path]} (config)", "#{e.class}: #{e.message}", required: defn[:required])
-            end
+            plugin = load_plugin(hooks_dir, defn[:path], settings: defn[:settings])
+            # Persistent: config hooks must fire on every turn, not be wiped
+            # by Engine#run_turn's per-turn clear_hooks after turn 1.
+            registry.register_persistent(defn[:event_type].to_sym, label: "#{defn[:path]} (config)",
+                                         &wrapped(plugin, defn))
+          rescue ScriptError, StandardError => e
+            # ScriptError: a SyntaxError (or LoadError) from `require`.
+            Log.error(:hooks, "hook_load_failed", echo: "[samagotchi:hooks] hook #{defn[:path]} failed to load: #{e.class}: #{e.message}", hook: defn[:path].to_s, error: e.class.name)
+            failures&.add("hook #{defn[:path]} (config)", "#{e.class}: #{e.message}", required: defn[:required])
           end
 
           registry
@@ -87,6 +85,7 @@ module Samagotchi
       # Expand a path that may start with ~.
       def self.expand_path(path, env = ENV)
         return path unless path.start_with?("~")
+
         home = env["HOME"] || Dir.home
         File.join(home, path[1..])
       end
@@ -97,8 +96,10 @@ module Samagotchi
         definitions = []
         hooks_config.each do |event_type, configs|
           next unless event_type.to_s != "hooks_dir" && configs.is_a?(Array)
+
           configs.each do |cfg|
             next unless cfg.is_a?(Hash) && cfg["path"]
+
             definitions << {
               event_type: event_type.to_s,
               path: cfg["path"],
@@ -123,9 +124,7 @@ module Samagotchi
 
         # Check if already loaded (Ruby's require caching handles this)
         # We cache the instance separately to avoid re-instantiating
-        unless @plugin_cache
-          @plugin_cache = {}
-        end
+        @plugin_cache ||= {}
 
         @plugin_cache[[full_path, settings]] ||= begin
           require full_path
@@ -133,6 +132,7 @@ module Samagotchi
           instance = Hooks.build_plugin(klass, settings)
           # Validate that the instance responds to #call
           raise ArgumentError, "Plugin #{klass.name} does not respond to #call" unless instance.respond_to?(:call)
+
           instance
         end
       end
@@ -142,9 +142,11 @@ module Samagotchi
       # on_error: log warns and skip is silent.
       def self.wrapped(plugin, defn)
         if defn[:required] && defn[:event_type] == "before_tool_call"
-          policy, label = :deny, "required hook #{defn[:path]}"
+          policy = :deny
+          label = "required hook #{defn[:path]}"
         else
-          policy, label = (defn[:on_error] == "log" ? :log : :skip), "#{defn[:path]} (config)"
+          policy = (defn[:on_error] == "log" ? :log : :skip)
+          label = "#{defn[:path]} (config)"
         end
         Hooks.wrap(label: label, event: defn[:event_type].to_sym, policy: policy) { |event| plugin.call(event) }
       end

data/lib/samagotchi/hooks/registry.rb

@@ -13,7 +13,11 @@ module Samagotchi
     # @param settings [Hash]
     def self.build_plugin(klass, settings)
       takes_settings = klass.instance_method(:initialize).arity != 0
-      takes_settings ? klass.new(settings.is_a?(Hash) ? settings : {}) : klass.new
+      if takes_settings
+        klass.new(settings.is_a?(Hash) ? settings : {})
+      else
+        klass.new
+      end
     end
 
     # A stream hook (:generation_progress) fires ~once a second: a broken
@@ -62,7 +66,7 @@ module Samagotchi
     def self.wrap(label:, event:, policy:, log: [:hooks, "hook_failed"], echo: true, fields: {}, &block)
       log_failure = failure_log_gate(event)
       lambda do |payload|
-        block.call(payload)
+        yield(payload)
       rescue Exception => e # rubocop:disable Lint/RescueException -- :deny fails closed on anything
         raise unless policy == :deny || e.is_a?(StandardError) || e.is_a?(ScriptError)
 
@@ -130,6 +134,7 @@ module Samagotchi
       def register(name, &block)
         raise ArgumentError, "hook name must be a Symbol" unless name.is_a?(Symbol)
         raise ArgumentError, "hook block is required" unless block_given?
+
         @mutex.synchronize { (@hooks[name] ||= []) << block }
       end
 
@@ -144,6 +149,7 @@ module Samagotchi
       def register_persistent(name, label: nil, &block)
         raise ArgumentError, "hook name must be a Symbol" unless name.is_a?(Symbol)
         raise ArgumentError, "hook block is required" unless block_given?
+
         label = label.to_s.strip
         label = CONFIG_HOOK_LABEL if label.empty?
         @mutex.synchronize { (@persistent_hooks[name] ||= []) << { label: label, proc: block } }
@@ -160,6 +166,7 @@ module Samagotchi
       # @return [void]
       def register_bundle(bundle_name, event_name, hook_name:, priority: 100, &block)
         raise ArgumentError, "hook block is required" unless block_given?
+
         @mutex.synchronize do
           (@bundle_hooks[event_name] ||= []) << {
             bundle: bundle_name,
@@ -180,6 +187,7 @@ module Samagotchi
           if event_name
             arr = @bundle_hooks[event_name]
             return 0 unless arr
+
             before = arr.size
             @bundle_hooks[event_name] = arr.reject { |h| h[:bundle] == bundle_name }
             removed = before - @bundle_hooks[event_name].size

data/lib/samagotchi/host_registry.rb

@@ -118,9 +118,7 @@ module Samagotchi
       @model_index = nil # downcased model_id => [host_name] in hosts: order
     end
 
-    def entries
-      @entries
-    end
+    attr_reader :entries
 
     # Loopback, private (RFC 1918, IPv6 unique local) and link-local nets.
     LOCAL_NETS = %w[127.0.0.0/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10

data/lib/samagotchi/idle_recap.rb

@@ -46,7 +46,7 @@ module Samagotchi
     module TranscriptFilter
       # A tool call as the model wrote it inline: gemma, qwen, or the qwen
       # prompt-literal form. An unterminated gemma call runs to the end.
-      TOOL_CALL_RE = /<\|tool_call>(?:.*?<tool_call\|>|.*\z)|<tool_call>.*?<\/tool_call>|\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_OPEN\]\].*?\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_CLOSE\]\]/m
+      TOOL_CALL_RE = %r{<\|tool_call>(?:.*?<tool_call\|>|.*\z)|<tool_call>.*?</tool_call>|\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_OPEN\]\].*?\[\[SAMAGOTCHI_LITERAL_TOOL_CALL_CLOSE\]\]}m
       # Each dispatched call's output starts with "[name]"; the kernel loop
       # joins one step's outputs into a single tool_response with this
       # separator, while the chat loop writes one message per call.
@@ -215,7 +215,7 @@ module Samagotchi
         system = format(SYSTEM, range) + (previous ? UPDATE + format(UPDATE_LENGTH, range) : "") + tools
         user = +""
         user << "Earlier recap:\n#{previous}\n\n" if previous
-        user << "Transcript#{previous ? ' since the earlier recap' : ''} (the system prompt and tool " \
+        user << "Transcript#{" since the earlier recap" if previous} (the system prompt and tool " \
                 "internals were removed; only user turns and assistant prose remain):\n---\n#{body}\n---\n"
         user << "#{OFFER_LINE}\n" if offer
         user << "Write the recap now."
@@ -225,7 +225,7 @@ module Samagotchi
       # "2-4 sentences", or "3 sentences" for [3, 3] ("1 sentence" for [1, 1])
       def sentences_text((min, max), adjective = "")
         count = min == max ? min.to_s : "#{min}-#{max}"
-        "#{count} #{adjective}#{max == 1 ? 'sentence' : 'sentences'}"
+        "#{count} #{adjective}#{max == 1 ? "sentence" : "sentences"}"
       end
 
       # The tail of +body+ when it is over MAX_NEW_CHARS, from a paragraph
@@ -243,7 +243,7 @@ module Samagotchi
       def tools_used(names)
         return "" if names.empty?
 
-        " (#{names.tally.map { |name, n| n > 1 ? "#{name} x#{n}" : name }.join(', ')})"
+        " (#{names.tally.map { |name, n| n > 1 ? "#{name} x#{n}" : name }.join(", ")})"
       end
     end
 
@@ -395,6 +395,17 @@ module Samagotchi
       @engine.activity_seq > @last_fire_activity_seq
     end
 
+    # SHA1 of one message's role and text: detects a rewrite a count alone
+    # misses. Model text is taken without its thinking, which is dropped from
+    # older model messages when the next turn starts.
+    def self.digest(message)
+      return nil unless message.is_a?(Hash)
+
+      text = message["content"].to_s
+      text = TranscriptFilter.strip_thought(text) if %w[model assistant].include?(message["role"])
+      Digest::SHA1.hexdigest("#{message["role"]}\0#{text}")
+    end
+
     private
 
     # A failing check writes the recap without the offer line.
@@ -431,9 +442,11 @@ module Samagotchi
       # Nothing new said (only notes, tool traffic, or no messages at all):
       # the recap still stands, so no request.
       return :nothing_new if transcript.strip.empty?
+
       prompt = RecapPrompt.build(transcript, tool_names: TranscriptFilter.tool_names(fresh), previous: previous&.dig(:text),
                                                      sentences: @sentences, offer: offer_open?)
       return :nothing_new if prompt.nil?
+
       asked = target
       @in_flight = { thread: spawn_summarize(client_for(asked), prompt), generation: gen, deadline: @clock.call + @timeout,
                      covered: parsed.size, covered_digest: self.class.digest(parsed.last), model: asked[:label] }
@@ -459,6 +472,7 @@ module Samagotchi
       @in_flight = nil
       recap = safe_value(job[:thread])
       return if recap.nil? || recap.to_s.strip.empty?
+
       # An IdleClient::Summary names the model that answered; a plain String
       # (a stubbed client) doesn't, and the asked label stands in.
       served = recap.model if recap.respond_to?(:model)
@@ -503,17 +517,6 @@ module Samagotchi
       saved
     end
 
-    # SHA1 of one message's role and text: detects a rewrite a count alone
-    # misses. Model text is taken without its thinking, which is dropped from
-    # older model messages when the next turn starts.
-    def self.digest(message)
-      return nil unless message.is_a?(Hash)
-
-      text = message["content"].to_s
-      text = TranscriptFilter.strip_thought(text) if %w[model assistant].include?(message["role"])
-      Digest::SHA1.hexdigest("#{message['role']}\0#{text}")
-    end
-
     def bump_generation
       @mutex.synchronize { @generation += 1 }
     end

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)
@@ -379,7 +393,7 @@ module Samagotchi
     # 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)
@@ -493,7 +507,6 @@ module Samagotchi
       nil
     end
 
-
     # ── Hook dispatch helper ───────────────────────────────────────────────────
 
     # Fire a named hook on the registry (if present).
@@ -505,6 +518,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 +531,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 +563,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 +632,7 @@ module Samagotchi
       @parser_profile = @profile
       @parser
     end
+
     private
 
     # The generation's thinking: what the stream split into the thinking
@@ -682,6 +680,7 @@ module Samagotchi
     end
 
     public
+
     # Public entry point for executing an ALREADY-NORMALIZED internal tool call
     # (the {name:, content:, path:, scope:, …} shape).
     #
@@ -696,6 +695,7 @@ module Samagotchi
     end
 
     private
+
     def dispatch(call)
       entry = @tools[call[:name]]
       unless entry
@@ -723,7 +723,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

@@ -155,12 +155,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
@@ -449,10 +452,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

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)