samagotchi 0.44.0 → 0.46.0

data/lib/samagotchi/engine.rb

@@ -481,11 +481,16 @@ module Samagotchi
 
     # The model notes the session's prompt carried at its last build
     # (Session#prompt_notes): a resumed session's or a woken worker's saved
-    # ones until this process builds its prompt; without a session, the
-    # notes the effective model's prompt would load.
+    # ones until this process builds its prompt; a fresh session (no build
+    # yet, no messages) has none saved, so the effective model's prompt
+    # would load them: the notes #model_notes names, as without a session.
+    # The three readers (/model, /stats, the web) share this.
     # @return [Array<PromptNote>]
     def prompt_notes
-      return @session.prompt_notes.dup if @session
+      return model_notes.map { |note| PromptNote.from_note(note) } unless @session
+
+      saved = @session.prompt_notes
+      return saved.dup if !@prompt_builder.prompt_notes.nil? || !saved.empty? || @session.messages.to_a.any?
 
       model_notes.map { |note| PromptNote.from_note(note) }
     rescue StandardError
@@ -945,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)
@@ -1040,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
@@ -1060,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
@@ -1080,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?,
@@ -1819,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
 
@@ -1913,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
@@ -2544,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,
@@ -2561,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
@@ -2633,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
 
@@ -235,6 +241,26 @@ module Samagotchi
       end
     end
 
+    # List one host's models and save them to ModelListStore: what
+    # ModelProfile.model_warning re-lists on a miss (a fresh saved list that
+    # lacks the id: the server may have been reloaded with another model),
+    # so the saved list catches up at spawn time. Only that host is asked,
+    # and never through the cache (a fresh listing is the point).
+    # @param name [String, Symbol, nil] a host name; anything else lists
+    #   nothing
+    # @return [Array<String>, nil] the ids the host lists now, nil for an
+    #   unknown name or when the host fails to list (nothing is saved then:
+    #   a host that is down keeps the ids we know)
+    def list_models(name)
+      entry = name.nil? ? nil : find_entry(name)
+      return nil unless entry
+
+      save_model_list(entry.name, list_models_for(entry))&.ids
+    rescue StandardError => e
+      Log.warn(:model, "list_failed", host: name.to_s, error: e.class.name, msg: e.message.to_s[0, 500])
+      nil
+    end
+
     def client_for_model(raw_model)
       host_entry, bare = host_for_model(raw_model)
       [client_for(host_entry), bare, host_entry]
@@ -293,9 +319,7 @@ module Samagotchi
             models = list_models_for(entry)
             data = { host: entry.host, port: entry.port, transport: entry.transport, models: models, error: nil }
             @mutex.synchronize { @host_lists[name] = { data: data, at: @clock.call } }
-            # On disk too: a process that spawns a worker without listing
-            # (`chi send --new --model`, delegate) checks an id against it.
-            ModelListStore.save(name, models.map(&:id))
+            save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
             data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: e.message }
@@ -350,6 +374,13 @@ module Samagotchi
 
     private
 
+    # Save a host's just-listed models on disk, for the processes that spawn
+    # a worker without listing (`chi send --new --model`, delegate):
+    # ModelListStore is what they check an id against.
+    def save_model_list(name, models)
+      ModelListStore.save(name, Array(models).map(&:id))
+    end
+
     def fresh_list(name, entry)
       @mutex.synchronize do
         cached = @host_lists[name]

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

data/lib/samagotchi/llm_context_strategy.rb

@@ -167,6 +167,43 @@ module Samagotchi
                     budget_tokens: budget_origin)
     end
 
+    # A session's LLM context strategy, apply rule and budget, each with
+    # where it came from (Explained#summary), as its worker would resolve
+    # them; nil when they can't be (an unreadable config, a model that
+    # resolves nowhere). Resolves from config and the registry only: no
+    # network, no model call. What a session page, a session list's ctx %
+    # and a spawn-time check all read.
+    # @param session [Session, nil]
+    # @param registry [HostRegistry, nil] the hosts to resolve against;
+    #   HostRegistry.new by default (what the caller usually has)
+    # @return [Hash, nil] Explained#summary, symbol keys
+    def for_session(session, registry: nil)
+      return nil if session.nil?
+
+      require_relative "config"
+      registry ||= begin
+        require_relative "host_registry"
+        HostRegistry.new
+      end
+      name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
+      target = registry.resolve(name)
+      names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
+      own = session.llm_context
+      explain(target, names: names, **(own&.resolve_args || {})).summary(own)
+    rescue StandardError
+      nil
+    end
+
+    # The budget a session's turns run under (for_session's :budget_tokens),
+    # nil when it is off or can't be resolved. What a session list's ctx %
+    # counts against, so a saved session's fill reads as the live meter.
+    # @param session [Session, nil]
+    # @param registry [HostRegistry, nil] see .for_session
+    # @return [Integer, nil]
+    def session_budget(session, registry: nil)
+      for_session(session, registry: registry)&.fetch(:budget_tokens, nil)
+    end
+
     # [the budget, its Origin]: the session's own first (0 there is off,
     # whatever the model says).
     def budget_for(target, names, models, session_budget)

data/lib/samagotchi/model_catalog.rb

@@ -7,33 +7,37 @@ module Samagotchi
   # picks from: GET /api/models and `chi models`. Every name question goes
   # to ModelRef / HostRegistry#resolve; nothing here parses a ref.
   module ModelCatalog
-    # host: the host that listed the id; ref: the name `--model` takes for
-    # it (see .spell).
-    Row = Data.define(:host, :id, :ref)
-    # rows: the default host's first, then the others by name; warnings:
+    # host: the host that listed (or declares) the id; ref: the name
+    # `--model` takes for it (see .spell); configured: declared under
+    # hosts.<name>.models (HostModel.rows).
+    Row = Data.define(:host, :id, :ref, :configured) do
+      def initialize(host:, id:, ref:, configured: false) = super
+    end
+    # rows: the default host's first, then the others by name, each host's
+    # declared ids first (HostModel.rows); warnings:
     # "host: error" per host that failed.
     Listing = Data.define(:rows, :warnings)
 
     module_function
 
     # @param results [Hash] list_all_models' answer
-    # @param registry [#default_entry]
+    # @param registry [#default_entry, #entries]
     # @return [Listing]
     def listing(results, registry:)
       default_host = registry.default_entry&.name
       rows = []
       warnings = []
+      host_rows = HostModel.rows(results, registry.entries)
       results.keys.sort_by { |name| [name == default_host ? 0 : 1, name] }.each do |host|
-        data = results[host]
-        if data[:error]
-          warnings << "#{host}: #{data[:error]}"
+        if results[host][:error]
+          warnings << "#{host}: #{results[host][:error]}"
           next
         end
-        Array(data[:models]).each do |info|
-          id = info.id.to_s
-          next if id.strip.empty? || id.end_with?(":batch")
+        host_rows[host].each do |row|
+          id = row.id
+          next if id.strip.empty? || (!row.configured && id.end_with?(":batch"))
 
-          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host))
+          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host), configured: row.configured)
         end
       end
       Listing.new(rows: rows, warnings: warnings)
@@ -58,6 +62,7 @@ module Samagotchi
       listing = listing(results, registry: registry)
       models = listing.rows.map do |row|
         hash = { name: row.ref, host: row.host, id: row.id }
+        hash[:configured] = true if row.configured
         shadow = shadowed_by(row, registry)
         shadow ? hash.merge(shadowed_by: shadow) : hash
       end