samagotchi 0.66.0 → 0.68.0

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.
@@ -719,9 +673,13 @@ module Samagotchi
 
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
       # link of that session's chain (SessionManager.continue_session), in its
-      # folder, on its model and with its own setup (SessionSetup: llm_context,
-      # thinking and reasoning_history levels), so dir, model, llm_context and
-      # thinking are refused beside it (a create takes no reasoning_history).
+      # folder and with its own setup (SessionSetup: llm_context, thinking
+      # and reasoning_history levels), so dir, llm_context and thinking are
+      # refused beside it (a create takes no reasoning_history). It runs on
+      # model (or model_name) when given, else on the previous link's: one
+      # whose host is gone falls back to the default, and the 201's
+      # model_warning (null when none) says so. A model it can't start on is
+      # 400 invalid_model, nothing archived.
       # 409 continued (with next_id, the link that continues it already: the
       # page opens that one), open_children (ids), folder_gone, busy, scratch
       # or owned_by_tui.
@@ -730,14 +688,16 @@ module Samagotchi
         unless given.is_a?(String) && !given.strip.empty?
           return error_response(400, "invalid_continues", "continues is a session id")
         end
-        if (fields = %w[dir model model_name llm_context thinking].select { |key| body.key?(key) }).any?
+        if (fields = %w[dir llm_context thinking].select { |key| body.key?(key) }).any?
           return error_response(400, "invalid_continues",
-                                "continues takes the previous session's folder, model, llm_context and thinking; " \
+                                "continues takes the previous session's folder, llm_context and thinking; " \
                                 "leave out #{fields.join(", ")}")
         end
 
         preview = idle ? body["preview"].to_s.strip : ""
-        session, error = continue_from(given, prompt: idle ? nil : prompt.to_s, title: preview.empty? ? nil : preview)
+        model = (body["model"] || body["model_name"]).to_s.strip
+        session, error = continue_from(given, prompt: idle ? nil : prompt.to_s, title: preview.empty? ? nil : preview,
+                                              model: model.empty? ? nil : model)
         return error if error
 
         port = await_bridge_port(session.id)
@@ -745,14 +705,15 @@ module Samagotchi
         # The moved delegates' cards fold under the new link now.
         [session.continues, session.id, *moved].each { |sid| @hub&.touch(sid) }
         record_history(body, prompt) if !idle && PromptHistory.shell_line?(prompt.to_s.strip)
-        json_response(201, session_to_json(session).merge(bridge_port: port, moved: moved))
+        json_response(201, session_to_json(session).merge(bridge_port: port, moved: moved,
+                                                          model_warning: session.model_warning))
       end
 
       # SessionManager.continue_session, its refusals as responses: [session,
       # nil] or [nil, the response]. Only its own errors: what fails after
       # the new link started is not a refusal of it.
-      def continue_from(given, prompt:, title:)
-        [@manager.continue_session(given, prompt: prompt, title: title, state_dir: @state_dir), nil]
+      def continue_from(given, prompt:, title:, model:)
+        [@manager.continue_session(given, prompt: prompt, title: title, model: model, state_dir: @state_dir), nil]
       rescue SessionContinue::Refused => e
         extra = e.reason == :continued ? { next_id: e.ids.first } : { ids: e.ids }
         [nil, json_response(409, { error: e.reason.to_s, detail: e.message, **extra })]
@@ -821,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,
@@ -879,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,
@@ -896,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
@@ -904,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

data/lib/samagotchi/web/capabilities.rb

@@ -3,7 +3,7 @@
 module Samagotchi
   module Web
     # What this web page renders that a notice may stand in for
-    # (Engine#hook_notify's fallback_for:), and what this viewer can do. The
+    # (HookRoutes#notify's fallback_for:), and what this viewer can do. The
     # session and tail JSON carry it as +capabilities+; the page leaves out
     # a notice whose fallback_for names a capability that is true here.
     # +display+: the answer's display is rendered as markdown, so its links

data/lib/samagotchi/web/public/activity.js

@@ -6,7 +6,7 @@
 // state from :tool_call_started / :tool_call_completed events. Keeping the
 // state pure makes it unit-testable under `node --test` like data.js/format.js.
 
-export const ROW_STATUS = Object.freeze({
+const ROW_STATUS = Object.freeze({
   RUNNING: "running",
   OK: "ok",
   ERROR: "error",
@@ -161,7 +161,7 @@ function callDuration(row, event, now) {
 
 // A completed call's row status from the server's: error, stopped,
 // blocked, else ok.
-export function completedStatus(status) {
+function completedStatus(status) {
   if (status === "error") return ROW_STATUS.ERROR;
   if (status === "stopped") return ROW_STATUS.STOPPED;
   if (status === "blocked") return ROW_STATUS.BLOCKED;

data/lib/samagotchi/web/public/annotate_actions.js

@@ -15,7 +15,7 @@
 import { quoteBlock } from "./annotations.js";
 
 // How many plugin pills the bar shows; the rest go behind "⋯".
-export const INLINE_ACTIONS = 3;
+const INLINE_ACTIONS = 3;
 
 // The session's commands' annotations, flattened in listing order: {label,
 // line, template, send, command, anytime, source}. anytime: the command