samagotchi 0.45.0 → 0.46.0

data/lib/samagotchi/config.rb

@@ -10,6 +10,7 @@ require_relative "log"
 require_relative "model_ref"
 require_relative "paths"
 require_relative "llm_context_strategy"
+require_relative "host_model"
 
 module Samagotchi
   # Parses the thinking: levels of host and model entries (it needs Config).
@@ -263,10 +264,12 @@ module Samagotchi
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
       "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking enabled
-                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens].freeze,
+                    remote window_tokens llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
       "models" => %w[profile vision sampling thinking window_tokens llm_context_strategy llm_context_apply
                      llm_context_budget_tokens].freeze
     }.freeze
+    # The keys a hosts.<name>.models entry may hold (HostModel.parse_map).
+    HOST_MODEL_KEYS = %w[price served].freeze
     # Section keys beyond the registry's: guardrails' YAML rules (Engine#guardrail_rules).
     SECTION_EXTRA_KEYS = { "guardrails" => %w[rules disable].freeze }.freeze
 
@@ -615,7 +618,29 @@ module Samagotchi
 
           (entry.keys.map(&:to_s) - allowed).map do |k|
             unknown_key_message("#{map}.#{name}.#{k}", k, allowed, prefix: "#{map}.#{name}.")
-          end
+          end + (map == "hosts" ? host_model_problems(name, entry["models"]) : [])
+        end
+      end
+
+      # hosts.<name>.models' entries, one level further down.
+      def host_model_problems(host, models)
+        return [] unless models.is_a?(Hash)
+
+        models.flat_map do |id, model|
+          next [] unless model.is_a?(Hash)
+
+          prefix = "hosts.#{host}.models.#{id}."
+          (model.keys.map(&:to_s) - HOST_MODEL_KEYS).map do |k|
+            unknown_key_message("#{prefix}#{k}", k, HOST_MODEL_KEYS, prefix: prefix)
+          end + price_key_problems("#{prefix}price.", model["price"])
+        end
+      end
+
+      def price_key_problems(prefix, price)
+        return [] unless price.is_a?(Hash)
+
+        (price.keys.map(&:to_s) - ModelPrice::KEYS).map do |k|
+          unknown_key_message("#{prefix}#{k}", k, ModelPrice::KEYS, prefix: prefix)
         end
       end
 
@@ -853,6 +878,7 @@ module Samagotchi
                                                  "hosts entry '#{name}'")
           llm_context_apply = LLMContextStrategy.parse_apply(raw_cfg.key?(LLMContextStrategy::APPLY_KEY) ? raw_cfg[LLMContextStrategy::APPLY_KEY] : raw_cfg[:llm_context_apply],
                                                              "hosts entry '#{name}'")
+          models = HostModel.parse_map(raw_cfg.key?("models") ? raw_cfg["models"] : raw_cfg[:models], name)
           llm_context_budget = LLMContextStrategy.parse_budget(raw_cfg.key?(LLMContextStrategy::BUDGET_KEY) ? raw_cfg[LLMContextStrategy::BUDGET_KEY] : raw_cfg[:llm_context_budget_tokens],
                                                                "hosts entry '#{name}'")
           unless first_token_timeout.nil? || (first_token_timeout.is_a?(Numeric) && !first_token_timeout.negative?)
@@ -920,8 +946,10 @@ module Samagotchi
                                   profile: profile.empty? ? nil : profile, first_token_timeout: first_token_timeout,
                                   vision: vision, sampling: sampling, thinking: thinking, remote: remote,
                                   window_tokens: window, llm_context_strategy: llm_context,
-                                  llm_context_apply: llm_context_apply, llm_context_budget_tokens: llm_context_budget }
+                                  llm_context_apply: llm_context_apply, llm_context_budget_tokens: llm_context_budget,
+                                  models: models }
         end
+        warn_duplicate_host_models(normalized)
       end
 
       # If no hosts defined, synthesize "default" from server.host/port/transport.
@@ -941,6 +969,30 @@ module Samagotchi
       {}
     end
 
+    # hosts.<name>.models as written back (HostModel#to_config), nil when none.
+    def host_models_config(models)
+      models.values.to_h { |m| [m.id, m.to_config] } unless models.nil? || models.empty?
+    end
+    private_class_method :host_models_config
+
+    # Two hosts declaring one id under hosts.<name>.models: a bare id goes
+    # where HostRegistry#host_for_model sends it (the default host when it
+    # declares the id, else the first in hosts: order); say so once.
+    def warn_duplicate_host_models(hosts)
+      declared = Hash.new { |h, k| h[k] = [] }
+      hosts.each { |name, cfg| cfg[:models].each { |down, model| declared[down] << [name, model.id] } }
+      declared.each_value do |owners|
+        next if owners.size < 2
+
+        names = owners.map(&:first)
+        id = owners.first.last
+        goes = names.include?("default") ? "default" : "#{names.first} unless the default host lists it"
+        warn_once "Warning: #{names.map { |n| "hosts.#{n}.models" }.join(" and ")} #{names.size == 2 ? "both" : "all"} declare #{id}; " \
+                  "a bare #{id} goes to #{goes}"
+      end
+    end
+    private_class_method :warn_duplicate_host_models
+
     # The names (lowercased) of the hosts entries with enabled: false, which
     # hosts_config leaves out. Read from the same source: config.yml's
     # hosts:, or SAMAGOTCHI_HOSTS_JSON in a worker.
@@ -1070,7 +1122,8 @@ module Samagotchi
                        "remote" => v[:remote], "window_tokens" => v[:window_tokens],
                        "llm_context_strategy" => v[:llm_context_strategy]&.map(&:to_s),
                        "llm_context_apply" => v[:llm_context_apply]&.to_s,
-                       "llm_context_budget_tokens" => v[:llm_context_budget_tokens]).compact
+                       "llm_context_budget_tokens" => v[:llm_context_budget_tokens],
+                       "models" => host_models_config(v[:models])).compact
       end
       # Disabled hosts travel as just that, so a worker refuses "box:x"
       # the way its parent does instead of sending it to the default host.

data/lib/samagotchi/desktop/macos/Panel.swift

@@ -980,6 +980,7 @@ final class PanelController: NSObject, NSWindowDelegate {
     let kittyText = windows.isEmpty ? "" : Kitty.text(context: model.hasContext ? model.text : "", message: model.trimmedPrompt,
                                                      imagePaths: ImageIntake.keepForPaste(images), pasteOnly: kind == .paste)
 
+    let open = opens
     let group = DispatchGroup()
     var chiOutcome: SendOutcome?
     var kittyOutcomes: [(KittyWindow, KittyError?)] = []
@@ -1004,6 +1005,9 @@ final class PanelController: NSObject, NSWindowDelegate {
       // another try, unless the panel was closed or reopened meanwhile.
       if ok { self.model.images.removeAll { images.contains($0) } }
       ImageIntake.delete(images.filter { !self.model.images.contains($0) })
+      // Reopened meanwhile (as for a broadcast): the new open keeps its
+      // message and phase, and isn't closed by this send's success.
+      guard self.opens == open else { return }
       var parts: [String] = []
       if let chiOutcome { parts.append(chiOutcome.message) }
       if !pasted.isEmpty {
@@ -1014,7 +1018,7 @@ final class PanelController: NSObject, NSWindowDelegate {
       if ok {
         self.model.phase = .sent
         DispatchQueue.main.asyncAfter(deadline: .now() + (chiOutcome?.linger ?? 1.0)) { [weak self] in
-          if self?.model.phase == .sent { self?.panel.close() }
+          if self?.opens == open, self?.model.phase == .sent { self?.panel.close() }
         }
       } else {
         self.model.phase = .failed
@@ -1022,8 +1026,8 @@ final class PanelController: NSObject, NSWindowDelegate {
     }
   }
 
-  /// Counts the panel's opens: a broadcast that ends after a reopen leaves
-  /// the new open alone.
+  /// Counts the panel's opens: a send or broadcast that ends after a
+  /// reopen leaves the new open alone.
   private var opens = 0
 
   /// The Everyone row: `chi broadcast` with the note (the source field is

data/lib/samagotchi/engine.rb

@@ -950,7 +950,8 @@ module Samagotchi
       snapshot = @metrics.snapshot
       target = @host_registry.resolve(@effective_model_name)
       served, served_for = served_model_for(snapshot, target: target)
-      snapshot = snapshot.merge(served_model: served, served_model_for: served_for, llm_context: llm_context_summary,
+      snapshot = snapshot.merge(served_model: served, served_model_for: served_for,
+                                served_expected_by: served_expected_by(served, target: target), llm_context: llm_context_summary,
                                 prompt_notes: prompt_notes.map(&:to_h))
       unless snapshot.dig(:context, :window_tokens)
         window = current_context_window(target)
@@ -1045,6 +1046,19 @@ module Samagotchi
       served_model_for(@metrics.served_report, target: probe ? @host_registry.resolve(@effective_model_name) : nil)
     end
 
+    # The host whose hosts.<name>.models.<id>.served names +served+ for the
+    # current model (a gateway's round-robin targets): not a mismatch to
+    # warn about. nil when none does.
+    # @return [String, nil]
+    def served_expected_by(served, target: nil)
+      target ||= @host_registry.resolve(@effective_model_name)
+      target.entry.name if target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.serves?(served)
+    rescue StandardError
+      nil
+    end
+
+    def served_expected?(served) = !served_expected_by(served).nil?
+
     # Read-only snapshot of the engine's view of the current session plus the
     # live event sequence. Cheap primitive used by the bridge's reconnect-too-
     # old reset marker and the GET /session/:id/state read surface. Orthogonal
@@ -1065,6 +1079,8 @@ module Samagotchi
     #   :served_model, :served_model_for [String, nil] what a generation of
     #     that model reported serving, and the name asked (#served_model
     #     without the probe)
+    #   :served_expected_by [String, nil] the host whose models: entry names
+    #     that served model under served: (#served_expected_by)
     #   :recap_enabled [Boolean]   whether an idle recap is configured, with
     #     :recap_min_user_turns and :recap_inactivity_seconds (nil when not)
     def session_state_snapshot
@@ -1085,6 +1101,7 @@ module Samagotchi
         model_name: effective_model_ref,
         served_model: served_pair[0],
         served_model_for: served_pair[1],
+        served_expected_by: served_expected_by(served_pair[0]),
         context_status: @last_context_status&.dup || saved_context_status(metrics[:context]),
         llm_context: llm_context_summary,
         recap_enabled: !@recap.nil?,
@@ -1824,7 +1841,7 @@ module Samagotchi
       @turn_thinking = [thinking_level(thinking_target), thinking_target]
       announce_thinking_level(*@turn_thinking)
       LLM::TurnSettings.new(vision: vision, sampling: sampling, thinking: @turn_thinking.first, model_name: nil,
-                            window_setting: nil, llm_context: nil)
+                            window_setting: nil, llm_context: nil, price: nil)
     end
     private :turn_settings
 
@@ -1918,7 +1935,7 @@ module Samagotchi
       # turn's model, not the last native one.
       explained = llm_context_explained
       @kernel.turn_settings = turn.settings.with(model_name: bare_for_backend, window_setting: turn_window_setting,
-                                                 llm_context: explained&.resolved)
+                                                 llm_context: explained&.resolved, price: turn_price)
       log_llm_context(explained)
 
       turn.limit = @no_interrupt ? IterationLimit.for(no_interrupt: true) : max_iterations || IterationLimit.for
@@ -2549,6 +2566,12 @@ module Samagotchi
         when :generation_started
           @generation_thought = nil
           watch&.started(event[:iteration])
+        when :generation_retrying
+          # A dropped stream's step asked again: it streams from the start.
+          if event[:restarted]
+            @generation_thought = nil
+            watch&.started(event[:iteration])
+          end
         when :generation_chunk then note_generation_thought(progress[:thinking])
         end
         # The chat loop asked again without the thinking fields: a notice,
@@ -2566,13 +2589,14 @@ module Samagotchi
     end
 
     # A :generation_completed with the generation's decode speed (`speed:`
-    # {decode_tps:, source:}, nil without one) and the session's running
-    # token totals (`tokens:`, the snapshot's block): the web's info bar
+    # {decode_tps:, source:}, nil without one), the session's running
+    # token totals (`tokens:`, the snapshot's block) and whether its served
+    # model is an expected one (`served_expected_by:`, its host): the web's info bar
     # reads them from the stream. SessionMetrics closes the generation here,
     # so the event it gets next finds it closed.
     def with_generation_report(event)
       report = @metrics.finish_generation
-      event.merge(speed: report.speed&.to_h, tokens: report.tokens)
+      event.merge(speed: report.speed&.to_h, tokens: report.tokens, served_expected_by: served_expected_by(event[:served_model]))
     rescue StandardError
       event
     end
@@ -2638,6 +2662,15 @@ module Samagotchi
       nil
     end
 
+    # The effective model's price on its host (hosts.<name>.models.<id>.price),
+    # by the requested id, never the served one; read per turn as the window is.
+    def turn_price
+      target = @host_registry.resolve(@effective_model_name)
+      target.entry.models&.dig(target.bare_model.to_s.strip.downcase)&.price
+    rescue StandardError
+      nil
+    end
+
     # The LLM context strategy the next turn runs under: the session's own
     # (Session#llm_context), else the effective model's (models:/hosts:
     # llm_context_strategy), else llm_context.strategy; read per turn as

data/lib/samagotchi/host_model.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "model_price"
+
+module Samagotchi
+  # A model a host serves, declared under hosts.<name>.models: whatever the
+  # host's /v1/models says (a gateway's round-robin ids it never lists). A
+  # declared id is known on its host: no "doesn't list" warning, no re-list,
+  # and a bare id routes there as if the host listed it
+  # (HostRegistry#host_for_model).
+  #
+  # id: the id as written (keys are matched downcased); price: its
+  # ModelPrice on this host, nil when none; served: the models the host may
+  # answer it with (a gateway's round-robin targets), exact ids as written
+  # or "any", nil when none: no served-model warning for those (#serves?).
+  HostModel = Data.define(:id, :price, :served) do
+    def initialize(id:, price: nil, served: nil) = super
+
+    # hosts.<name>.models as written: a map of ids (each nil or a map), or
+    # a plain list of ids. Anything else warns once and is skipped.
+    # @param raw [Hash, Array, nil]
+    # @param host_name [String] for the warnings
+    # @return [Hash{String => HostModel}] by downcased id, in written order
+    def self.parse_map(raw, host_name)
+      return {} if raw.nil?
+
+      where = "hosts.#{host_name}.models"
+      pairs = case raw
+              when Hash then raw.to_a
+              when Array then raw.map { |id| [id, nil] }
+              else
+                warn_once "Warning: #{where} must be a map or a list of model ids; ignored"
+                return {}
+              end
+      pairs.each_with_object({}) do |(id, entry), models|
+        id = id.to_s.strip if id.is_a?(String) || id.is_a?(Symbol)
+        unless id.is_a?(String) && !id.empty?
+          warn_once "Warning: #{where}: #{id.inspect} is not a model id; ignored"
+          next
+        end
+        unless entry.nil? || entry.is_a?(Hash)
+          warn_once "Warning: #{where}.#{id} must be empty or a mapping; ignored"
+          next
+        end
+        value = ->(key) { entry && (entry.key?(key) ? entry[key] : entry[key.to_sym]) }
+        price = ModelPrice.parse(value.call("price"), "#{where}.#{id}")
+        models[id.downcase] ||= new(id: id, price: price, served: parse_served(value.call("served"), "#{where}.#{id}"))
+      end
+    end
+
+    # served: a list of ids, or "any"; anything else warns once and is unset.
+    def self.parse_served(raw, where)
+      return nil if raw.nil?
+      return "any" if raw.is_a?(String) && raw.strip.casecmp?("any")
+
+      ids = raw.is_a?(Array) && raw.all? { |id| id.is_a?(String) && !id.strip.empty? } ? raw.map(&:strip) : nil
+      warn_once "Warning: #{where}.served must be a list of model ids or any; ignored" unless ids
+      ids
+    end
+    private_class_method :parse_served
+
+    # Whether the host answering this model with +name+ is expected
+    # (served: lists it, any case, or says any).
+    def serves?(name)
+      return false if served.nil? || name.to_s.strip.empty?
+
+      served == "any" || served.any? { |id| id.casecmp?(name.to_s.strip) }
+    end
+
+    # config.rb requires this file, so config is required here only when a
+    # warning needs it (this file loaded alone).
+    def self.warn_once(message)
+      require_relative "config"
+      ConfigFile.warn_once(message)
+    end
+    private_class_method :warn_once
+
+    # One host's rows as the listings show them, declared ids first, then
+    # the listed ones in the host's order (see Row). An id both declared and
+    # listed is one row. Pure: +results+ (list_all_models') is only read.
+    # A host that errored has no rows: its declared ids aren't shown
+    # either (the listings say it's unreachable).
+    # @param results [Hash{String => Hash}] host name => {models: [ModelInfo], error:}
+    # @param entries [Hash{String => HostRegistry::HostEntry}]
+    # @return [Hash{String => Array<Row>}] for the hosts that answered
+    def self.rows(results, entries)
+      results.each_with_object({}) do |(name, data), out|
+        next if data[:error]
+
+        infos = Array(data[:models])
+        by_id = infos.group_by { |info| info.id.to_s.downcase }
+        declared = entries[name]&.models || {}
+        out[name] = declared.values.map do |m|
+          info = by_id[m.id.downcase]&.first
+          # A listed id keeps the host's spelling: a case-sensitive server takes only that.
+          HostModel::Row.new(id: info ? info.id.to_s : m.id, configured: true, info: info)
+        end +
+                    infos.reject { |info| declared.key?(info.id.to_s.downcase) }
+                         .map { |info| HostModel::Row.new(id: info.id.to_s, configured: false, info: info) }
+      end
+    end
+
+    # The entry as written back to config (SAMAGOTCHI_HOSTS_JSON for
+    # workers): nil for a bare id.
+    def to_config
+      config = { "price" => price&.to_config, "served" => served }.compact
+      config unless config.empty?
+    end
+  end
+
+  # A listing row (HostModel.rows): id as the host lists it, else as
+  # declared;
+  # configured: declared under hosts.<name>.models; info: the host's
+  # ModelInfo for it, nil when only declared.
+  HostModel::Row = Data.define(:id, :configured, :info)
+end

data/lib/samagotchi/host_registry.rb

@@ -39,10 +39,12 @@ module Samagotchi
     # window_tokens: the configured context window (ContextWindow.setting), nil when unset;
     # llm_context_strategy: the configured layers (LLMContextStrategy), nil when unset;
     # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
-    # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset.
+    # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
+    # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
     HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :remote, :window_tokens,
-                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, keyword_init: true) do
+                           :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens, :models,
+                           keyword_init: true) do
       # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
       # raw-prompt loop.
       def chat? = api == :openai
@@ -104,7 +106,7 @@ module Samagotchi
                               vision: cfg[:vision], sampling: cfg[:sampling], thinking: cfg[:thinking],
                               remote: cfg[:remote], window_tokens: cfg[:window_tokens],
                               llm_context_strategy: cfg[:llm_context_strategy], llm_context_apply: cfg[:llm_context_apply],
-                              llm_context_budget_tokens: cfg[:llm_context_budget_tokens])
+                              llm_context_budget_tokens: cfg[:llm_context_budget_tokens], models: cfg[:models] || {})
         entry.client = Client.new(host: cfg[:host], port: cfg[:port], transport: transport, scheme: cfg[:scheme],
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
                                   api_key_env: entry.api_key_env, env: env)
@@ -116,7 +118,8 @@ module Samagotchi
         host = "localhost" if host.empty?
         port = Config.get("server.port").to_i
         port = 8080 if port <= 0
-        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, transport: nil, client: Client.new(host: host, port: port, name: "default"))
+        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, transport: nil, models: {},
+                                            client: Client.new(host: host, port: port, name: "default"))
       end
       @mutex = Mutex.new
       @cache = nil
@@ -195,18 +198,21 @@ module Samagotchi
 
     # The host a model name, alias or host:model ref goes to and the model
     # id it is sent as (ModelRef: one alias pass). A ref that names a host
-    # goes there. A bare id goes to the default host when its cached list
-    # has it, else to the first host in hosts: order whose list has it,
-    # else to the default host (before /models nothing is listed: no
+    # goes there. A bare id goes to the hosts whose cached list has it or
+    # that declare it (hosts.<name>.models, known before any /models): the
+    # default host when it is one of them, else the first in hosts: order,
+    # else the default host (before /models nothing is listed: no
     # discovery here, the latency budget). Never by a substring.
     def host_for_model(raw_model)
       ref = model_ref(raw_model)
       # ModelRef names a host only when it is one of ours
       return [find_entry(ref.host_name), ref.id] if ref.host_name
 
-      listed = @mutex.synchronize { @model_index }&.fetch(ref.id.to_s.strip.downcase, nil) || []
+      down = ref.id.to_s.strip.downcase
+      listed = @mutex.synchronize { @model_index }&.fetch(down, nil) || []
+      candidates = @entries.values.select { |e| listed.include?(e.name) || e.models&.key?(down) }.map(&:name)
       default = default_entry
-      name = listed.include?(default.name) ? default.name : listed.first
+      name = candidates.include?(default.name) ? default.name : candidates.first
       [(name && find_entry(name)) || default, ref.id]
     end
 

data/lib/samagotchi/kernel_loop.rb

@@ -353,7 +353,8 @@ module Samagotchi
       # thought or a tool call doesn't leave the next one "inside" it.
       stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
       emit(turn, type: :generation_started, iteration: turn.iteration, context_window_tokens: request.window.tokens,
-                 context_window_source: request.window.source, profile: @profile.name, profile_source: @profile_source)
+                 context_window_source: request.window.source, profile: @profile.name, profile_source: @profile_source,
+                 price: @turn_settings.price&.to_h)
       # This generation's own server counts (the run-long ones in the
       # context tracker can be an earlier one's), and the thinking it
       # streamed, for the log (a stuck thinking generation shows as

data/lib/samagotchi/llm/chat_loop.rb

@@ -54,10 +54,49 @@ module Samagotchi
       #   per turn for the effective model's host
       # @param stable_length [#call, nil] text → the length of the system
       #   prompt's part every session shares (SystemPrompt#stable_length), or nil
-      def initialize(kernel:, adapter: nil, stable_length: nil)
+      # @param sleeper [#call, nil] waits the given seconds before a dropped
+      #   stream's step is asked again (specs pass one that doesn't sleep)
+      def initialize(kernel:, adapter: nil, stable_length: nil, sleeper: nil)
         @kernel = kernel
         @adapter = adapter
         @stable_length = stable_length
+        @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+      end
+
+      # How many times a dropped stream's step may be asked again: +cap+, or
+      # retry.max when that is smaller (retry.max: 0 turns it off, as it
+      # does the transport's retries).
+      def stream_drop_limit(cap)
+        [cap, HTTP::RetryPolicy.from_config.max].min
+      rescue StandardError
+        cap
+      end
+
+      # The seconds before the +attempt+-th ask-again of a dropped stream's
+      # step: the transport's own backoff (retry.base_delay doubling, capped
+      # at retry.max_delay; LLM::HTTP::RetryPolicy), 0 when retry.max is
+      # spent.
+      def generation_retry_delay(attempt)
+        HTTP::RetryPolicy.from_config.delay_for(attempt) || 0.0
+      rescue StandardError
+        0.0
+      end
+
+      # Waits +seconds+ in short slices, raising RequestCancelled as soon as
+      # one of +controllers+ (the turn's, the generation's) is cancelled, as
+      # LLM::HTTP's own wait between retries does.
+      def wait_retry(seconds, *controllers)
+        remaining = seconds.to_f
+        while remaining.positive?
+          cancelled = controllers.compact.find(&:cancelled?)
+          raise RequestCancelled, cancelled.reason if cancelled
+
+          slice = [remaining, 0.05].min
+          @sleeper.call(slice)
+          remaining -= slice
+        end
+        cancelled = controllers.compact.find(&:cancelled?)
+        raise RequestCancelled, cancelled.reason if cancelled
       end
 
       def provider = :chat
@@ -180,6 +219,9 @@ module Samagotchi
       # turn_settings), or nil.
       def vision = @kernel.turn_settings.vision
 
+      # The turn's configured price (the kernel's turn_settings), or nil.
+      def price = (@kernel.turn_settings&.price if @kernel.respond_to?(:turn_settings))
+
       # The turn's request parameters (the kernel's turn_settings).
       def sampling = @kernel.turn_settings.sampling || {}
 
@@ -461,20 +503,22 @@ module Samagotchi
           observe_context(iteration, window)
           retry_generation = @empty_retry.take_sampling!
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
-               context_window_source: window&.source)
+               context_window_source: window&.source, price: @loop.price&.to_h)
           @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
           streamed = +""
           thought = +""
-          response = with_generation do |generation_controller|
+          generation_controller = nil
+          response = with_generation do |controller|
+            generation_controller = controller
             begin
-              request(iteration, retry_generation, streamed, thought, generation_controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, 0, controller)
             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, thought, generation_controller)
+              request_with_drops(iteration, retry_generation, streamed, thought, 0, controller)
             end
           rescue RequestCancelled
             raise unless generation_controller&.cancelled? && !@cancel_controller.cancelled?
@@ -522,7 +566,7 @@ module Samagotchi
           [response, nil]
         end
 
-        def request(iteration, retry_generation, streamed, thought, generation_controller)
+        def request(iteration, retry_generation, streamed, thought, generation_controller, streamed_any = nil)
           @loop.adapter.chat(
             messages: @loop.wire_messages(@conversation), tools: @loop.tool_definitions, model: @model_name,
             cancel_controller: generation_controller || @cancel_controller, session_id: @loop.session_id,
@@ -533,13 +577,51 @@ module Samagotchi
               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)
+              tool_call = OpenAIChat.tool_call_delta?(payload)
+              event[:tool_call] = true if tool_call
+              streamed_any&.call if !content.to_s.empty? || !reasoning.to_s.empty? || tool_call
               emit(event)
             },
             on_retry: ->(**retry_event) { emit({ type: :generation_retrying, iteration: iteration }.merge(retry_event)) }
           )
         end
 
+        # A dropped stream (LLM::HTTP raises RetryExhausted once a stream
+        # that already showed something fails, where a retry would repeat
+        # output) is asked again here, from the same conversation, up to
+        # MAX_STREAM_DROPS times per step (fewer under a smaller retry.max;
+        # none with 0), after the transport's backoff: the partial reply is
+        # dropped and the step restarts. A refusal or a first-token timeout
+        # fails as before, and a cancel (before or during the wait) never
+        # retries.
+        MAX_STREAM_DROPS = 2
+
+        # Runs one request, asking again on a mid-stream drop. +attempt+
+        # counts the drops already retried this step.
+        def request_with_drops(iteration, retry_generation, streamed, thought, attempt, generation_controller)
+          streamed_any = false
+          request(iteration, retry_generation, streamed, thought, generation_controller, -> { streamed_any = true })
+        rescue RetryExhausted => e
+          # A cancel that landed as the stream dropped ends the turn canceled,
+          # not failed, whatever the drop's count.
+          cancelled = [@cancel_controller, generation_controller].compact.find(&:cancelled?)
+          raise RequestCancelled, cancelled.reason if cancelled
+
+          limit = @loop.stream_drop_limit(MAX_STREAM_DROPS)
+          raise if attempt >= limit || !streamed_any
+
+          attempt += 1
+          streamed.clear
+          thought.clear
+          delay = @loop.generation_retry_delay(attempt)
+          # restarted: the step's streamed chunks so far are void (the UIs
+          # and the Bridge's TurnAccumulator drop them).
+          emit(type: :generation_retrying, iteration: iteration, attempt: attempt, max_retries: limit,
+               next_delay: delay, error_class: e.class.name, error_message: e.message, status: nil, restarted: true)
+          @loop.wait_retry(delay, @cancel_controller, generation_controller)
+          retry
+        end
+
         # A 400 about reasoning, for a request that carried thinking fields
         # (not a missing-tools, image or context error).
         def thinking_refused?(error)

data/lib/samagotchi/llm/turn_settings.rb

@@ -11,12 +11,14 @@ module Samagotchi
     # (Thinking.resolve), the bare model id the turn runs on (every debug
     # dump is tagged with it) and the model's or host's configured context
     # window (ContextWindow.setting, nil for none) and LLM context strategy
-    # (LLMContextStrategy.resolve, nil for none). The Engine sets them once
+    # (LLMContextStrategy.resolve, nil for none), and its price on its host
+    # (hosts.<name>.models.<id>.price, a ModelPrice; nil for none), what
+    # SessionMetrics estimates an unreported cost from. The Engine sets them once
     # per turn, in Engine#generate, after the model's host is synced.
-    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name, :window_setting, :llm_context) do
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name, :window_setting, :llm_context, :price) do
       # No vision, no sampling, the default thinking, no model name.
       def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil,
-                          window_setting: nil, llm_context: nil)
+                          window_setting: nil, llm_context: nil, price: nil)
     end
   end
 end