samagotchi 0.67.0 → 0.68.0

data/lib/samagotchi/thinking_notices.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "effective_model"
+require_relative "log"
+require_relative "thinking"
+
+module Samagotchi
+  # What the thinking level a turn runs at leads to, said to the user: a
+  # level its host can't do (an effort on a native host, or on a llama.cpp
+  # chat template that takes none), off that the model didn't honour, and a
+  # host refusing the thinking fields or the reasoning sent back. Each
+  # notice once per session and host; the log lines each time.
+  #
+  # Turn thread only (the turn's settings and its stream handler): no lock.
+  # What it needs from the Engine comes through lookups, called at use.
+  class ThinkingNotices
+    # @param session [#call] → Session, nil (its id: once per session)
+    # @param profile [#call] → ModelProfile (a native host's)
+    # @param notify  [#call] (text, level, source) → a notice
+    def initialize(session:, profile:, notify:)
+      @session = session
+      @profile = profile
+      @notify = notify
+      @said = Set.new
+      @turn = nil
+      @generation_thought = nil
+    end
+
+    # [level, HostRegistry::ModelTarget] the turn runs at, nil before one.
+    attr_reader :turn
+
+    # The turn's thinking level on +target+ (its EffectiveModel's), what
+    # the notices after it read; an effort a native host can't do is said
+    # now.
+    def turn_started(level, target)
+      @turn = [level, target]
+      announce_level(level, target)
+    end
+
+    # A generation starts (or a dropped one streams again from the start).
+    def generation_started = @generation_thought = nil
+
+    # Whether this generation's thinking lane said anything: nil while it
+    # streamed none, false while only whitespace (Gemma 4's empty thought
+    # with thinking off), true once a real thought came.
+    def note_thought(thinking)
+      return if thinking.empty?
+
+      @generation_thought ||= thinking.match?(/\S/)
+    end
+
+    # A generation completed: off that the model didn't honour, an effort
+    # its chat template ignores.
+    def generation_completed(event)
+      check_honoured(event)
+      announce_effort_ignored
+    end
+
+    # The host refused the level's request fields (gpt-oss can't turn
+    # thinking off) and the chat loop sent the request without them: said
+    # once per session and host, standing in for the not-honoured notice.
+    def thinking_refused(event)
+      _level, target = @turn
+      return unless target
+
+      Log.warn(:model, "thinking_refused", level: event[:level], host: target.entry.name, model: event[:model],
+                                           detail: event[:detail])
+      @said << [session_id, target.entry.name, :not_honoured]
+      notice_once(:refused, target, :warn,
+                  "#{target.entry.name} refused thinking: #{event[:level]} for #{event[:model]} (#{event[:detail]}); " \
+                  "sent without it, so thinking stays as the model has it")
+    rescue StandardError => e
+      failed(:thinking_refused, e)
+    end
+
+    # The host refused a sampling field (the empty-answer retry's
+    # temperature on a model that takes none) and the chat loop asked again
+    # without them, as it will for the model from now on: a log line.
+    def sampling_refused(event)
+      Log.info(:model, "sampling_refused", model: event[:model], detail: event[:detail])
+    rescue StandardError => e
+      failed(:sampling_refused, e)
+    end
+
+    # The host refused the model's reasoning sent back (reasoning_history)
+    # and the chat loop asked the step again without it, as it will from
+    # now on: logged, and said once per session and host.
+    def reasoning_history_refused(event)
+      _level, target = @turn
+      return unless target
+
+      Log.warn(:model, "reasoning_history_refused", level: event[:level], host: target.entry.name, model: event[:model],
+                                                    detail: event[:detail])
+      return unless @said.add?([session_id, target.entry.name, :reasoning_history_refused])
+
+      @notify.call("#{target.entry.name} refused reasoning sent back (reasoning_history: #{event[:level]}) for " \
+                   "#{event[:model]} (#{event[:detail]}); sent without it from now on", :warn, "reasoning history")
+    rescue StandardError => e
+      failed(:reasoning_history_refused, e)
+    end
+
+    private
+
+    # An effort on a native host, which has no knob for it: said once per
+    # session and host.
+    def announce_level(level, target)
+      return if target.entry.chat?
+
+      profile = @profile.call
+      return if Thinking.native(level, profile).honoured
+
+      notice_once(:unsupported, target, :info,
+                  "#{level} isn't supported by native #{profile.name} on #{target.entry.name}; " \
+                  "thinking stays as the model has it")
+    rescue StandardError => e
+      failed(:announce_level, e)
+    end
+
+    # An effort on a llama.cpp chat host whose chat template takes none
+    # (its /props says so): said once per session and host, as for a native
+    # host. Read from the /props answer the turn's window probe left in the
+    # cache, so it asks the server nothing.
+    def announce_effort_ignored
+      level, target = @turn
+      return unless target&.entry&.chat? && Thinking::EFFORTS.include?(level)
+
+      props = target.client.cached_server_props(model: target.bare_model)
+      return unless Thinking.effort_ignored?(level, props)
+
+      notice_once(:unsupported, target, :info,
+                  "#{level} isn't supported by #{target.bare_model}'s chat template on #{target.entry.name} " \
+                  "(/props: supports_reasoning_effort false); thinking stays as the model has it")
+    rescue StandardError => e
+      failed(:effort_ignored, e)
+    end
+
+    # Thinking off, and the model thought anyway: logged each time, said
+    # once per session and host. A thinking lane of whitespace alone is no
+    # thought.
+    def check_honoured(event)
+      level, target = @turn
+      chars = event[:thinking_chars].to_i
+      return unless level == :off && chars.positive? && target
+      return if @generation_thought == false
+
+      Log.warn(:model, "thinking_not_honoured", level: level, host: target.entry.name, model: target.bare_model, chars: chars)
+      notice_once(:not_honoured, target, :warn,
+                  "off wasn't honoured by #{target.bare_model} on #{target.entry.name} " \
+                  "(#{chars} chars of thinking); a sampling: override on the host or model may turn it off " \
+                  "(see Thinking in docs/configuration.md)")
+    rescue StandardError => e
+      failed(:check_honoured, e)
+    end
+
+    def notice_once(kind, target, level, text)
+      return unless @said.add?([session_id, target.entry.name, kind])
+
+      @notify.call(text, level, "thinking")
+    end
+
+    def session_id = @session.call&.id
+
+    # A notice that failed: none is said, the turn goes on; a log line
+    # (once per process for the notice, model and error class).
+    def failed(notice, error)
+      EffectiveModel::Unresolved.fallback(:thinking_notice_failed, @turn&.last&.model || notice.to_s, error, nil)
+    end
+  end
+end

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.67.0"
+  VERSION = "0.68.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -26,8 +26,8 @@ require_relative "../host_registry"
 require_relative "../llm_context_override"
 require_relative "../model_catalog"
 require_relative "../model_profile"
+require_relative "../session_setting"
 require_relative "../thinking"
-require_relative "../reasoning_history"
 require_relative "../sampling_settings"
 require_relative "../served_model"
 require_relative "../project_scope"
@@ -557,52 +557,6 @@ module Samagotchi
         nil
       end
 
-      # A session's LLM context strategy, apply rule and budget, each with
-      # where it came from (LLMContextStrategy::Explained#summary), as its
-      # worker would resolve them; nil when they can't be.
-      # (LLMContextStrategy.for_session, shared with the ctx % the session
-      # lists count.)
-      def llm_context_for(session)
-        LLMContextStrategy.for_session(session, registry: host_registry)
-      end
-
-      # A session's toolkit as its file names it ({name:, label:}), nil on
-      # full: without a worker nothing resolves it (a bundle's kits load in
-      # the worker), so the tools it leaves out aren't known here.
-      def toolkit_for(session)
-        toolkit = session.toolkit
-        toolkit && !toolkit.full? ? { name: toolkit.name, label: toolkit.label } : nil
-      end
-
-      # A session's thinking level with where it came from and its own
-      # (SettingExplained#summary), as its worker would resolve it; nil
-      # when it can't be. Config and the registry only: no network.
-      def thinking_for(session)
-        registry = host_registry
-        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)
-        Thinking.explain(target, names: names, session: session.thinking).summary
-      rescue StandardError
-        nil
-      end
-
-      # A session's reasoning_history level with where it came from and its
-      # own (SettingExplained#summary), as its worker would resolve it; nil
-      # on a native host (it ignores the level) or when it can't be. Config
-      # and the registry only: no network.
-      def reasoning_history_for(session)
-        registry = host_registry
-        name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
-        target = registry.resolve(name)
-        return nil unless target.entry&.chat?
-
-        names = registry.lookup_names(session.model_typed || name, resolved: name, target: target)
-        ReasoningHistory.explain(target, names: names, session: session.reasoning_history).summary
-      rescue StandardError
-        nil
-      end
-
       # Built again when config.yml's hosts: changed (compared as read: the
       # YAML read is mtime-cached), so the model picker lists a host added
       # while chi web runs. An injected registry (specs) stays.
@@ -828,46 +782,15 @@ module Samagotchi
         live = bridge_get_json(id, "snapshot")
         turn_snapshot = live && live["snapshot"]
         snapshot = live && live["session_state_snapshot"]
-        last_event_seq = snapshot ? snapshot["event_seq"] : bridge_event_seq(id)
+        last_event_seq = live_or_saved(snapshot, "event_seq") { bridge_event_seq(id) }
         current_turn = turn_snapshot && turn_snapshot["current_turn"]
         owner = session_owner(id)
-        # The file's question only while a worker owns the session: one a
-        # dead worker saved can't be answered (its turn is gone), nor a chi
-        # REPL's (it shares nothing with the web).
-        # A question between turns (the step-limit one) is the snapshot's own.
-        pending = if turn_snapshot
-                    current_turn ? current_turn["pending_question"] : turn_snapshot["pending_question"]
-                  elsif owner&.worker?
-                    session.pending_question
-                  end
-        # A /model in the worker changes it before the file catches up.
-        session.model_name = snapshot["model_name"] if snapshot && !snapshot["model_name"].to_s.empty?
-        session_json = session_to_json(session, status: displayed_status(session, snapshot, owner: owner), owner: owner)
+        pending = shown_pending_question(session, turn_snapshot, owner)
         # What the worker's server said it served for that model (after a turn);
         # without a worker, what the session's analytics.json last saved.
         persisted = snapshot ? nil : read_analytics(id)
-        if snapshot
-          session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"],
-                                            served_expected_by: snapshot["served_expected_by"])
-          # The model notes its prompt carries now (a /model there changes them).
-          session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
-        else
-          session_json = session_json.merge(saved_served_model(session, persisted))
-        end
-        # The LLM context strategy the next turn runs under (the info bar's
-        # chip): the worker's, else worked out here from the session file.
-        session_json = session_json.merge(llm_context: (snapshot && snapshot["llm_context"]) || llm_context_for(session))
-        # The thinking level the next turn runs at (the think chip), the same way.
-        session_json = session_json.merge(thinking: (snapshot && snapshot["thinking"]) || thinking_for(session))
-        # Its reasoning history (the reasoning chip): the worker's (nil on a
-        # native host), else the server's reading (an older worker, none).
-        history = snapshot&.key?("reasoning_history") ? snapshot["reasoning_history"] : reasoning_history_for(session)
-        session_json = session_json.merge(reasoning_history: history)
-        # Its toolkit when it isn't full (the tools chip): the worker's, which
-        # resolved it, else the name saved in the session file.
-        toolkit = snapshot&.key?("toolkit") ? snapshot["toolkit"] : toolkit_for(session)
-        session_json = session_json.merge(toolkit: toolkit)
-        raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
+        session_json = shown_session_json(session, snapshot, owner, persisted)
+        raw_messages = live_or_saved(turn_snapshot, "messages") { session.messages }
         timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"], persisted: persisted)
         json_response(200, {
           session: session_json,
@@ -886,7 +809,7 @@ module Samagotchi
           plugin_warning: turn_snapshot && turn_snapshot["plugin_warning"],
           # Plugins' slow setup still running (chi.init): the page's init row.
           init_tasks: turn_snapshot ? Array(turn_snapshot["init_tasks"]) : [],
-          cards: cards_for_display(turn_snapshot ? turn_snapshot["cards"] : saved_cards(id)),
+          cards: cards_for_display(live_or_saved(turn_snapshot, "cards") { saved_cards(id) }),
           # The composer's / autocomplete; the built-ins until a worker
           # names its plugins' too.
           commands: turn_snapshot&.fetch("commands", nil) || SessionCommands.builtin_registry.listing,
@@ -903,6 +826,54 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # A live worker's +key+ as its reading (+live+: a snapshot, a tail)
+      # says it, nil included; without a worker (+live+ nil) the block's,
+      # the server's own reading of the saved session. A nil value from a
+      # worker is not a missing one (contrast SessionSetting#snapshot_value's
+      # :or).
+      def live_or_saved(live, key)
+        live ? live[key] : yield
+      end
+
+      # The file's question only while a worker owns the session: one a
+      # dead worker saved can't be answered (its turn is gone), nor a chi
+      # REPL's (it shares nothing with the web).
+      # A question between turns (the step-limit one) is the snapshot's own.
+      def shown_pending_question(session, turn_snapshot, owner)
+        if turn_snapshot
+          current_turn = turn_snapshot["current_turn"]
+          current_turn ? current_turn["pending_question"] : turn_snapshot["pending_question"]
+        elsif owner&.worker?
+          session.pending_question
+        end
+      end
+
+      # The full show's session part: the file's, with what a live worker's
+      # state +snapshot+ knows first (its model, status, served model,
+      # prompt notes and chips); without one, the served model from
+      # +persisted+ (analytics.json). Sets a worker's model on +session+:
+      # a /model in the worker changes it before the file catches up.
+      def shown_session_json(session, snapshot, owner, persisted)
+        session.model_name = snapshot["model_name"] if snapshot && !snapshot["model_name"].to_s.empty?
+        session_json = session_to_json(session, status: displayed_status(session, snapshot, owner: owner), owner: owner)
+        if snapshot
+          session_json = session_json.merge(served_model: snapshot["served_model"], served_model_for: snapshot["served_model_for"],
+                                            served_expected_by: snapshot["served_expected_by"])
+          # The model notes its prompt carries now (a /model there changes them).
+          session_json = session_json.merge(prompt_notes: snapshot["prompt_notes"]) if snapshot["prompt_notes"].is_a?(Array)
+        else
+          session_json = session_json.merge(saved_served_model(session, persisted))
+        end
+        # The per-session settings' chips (the info bar's llm ctx, think,
+        # reasoning and tools): the worker's, else worked out here from the
+        # session file (SessionSetting#snapshot_value, #saved_summary).
+        SessionSetting::ALL.each do |setting|
+          chip = setting.snapshot_value(snapshot) { setting.saved_summary(session, registry: host_registry) }
+          session_json = session_json.merge(setting.key => chip)
+        end
+        session_json
+      end
+
       # ?cards=1: the page's re-read when a card arrives, for its rendered
       # body (the stream carries the card's plain text only). The worker's
       # cards from its light GET tail, else the saved ones; the session file
@@ -911,7 +882,7 @@ module Samagotchi
         return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
 
         tail = live_tail(id)
-        json_response(200, { cards: cards_for_display(tail ? tail["cards"] : saved_cards(id)) })
+        json_response(200, { cards: cards_for_display(live_or_saved(tail, "cards") { saved_cards(id) }) })
       end
 
       # ?tail=1: the page's re-read at the end of a turn wants the final