samagotchi 0.67.0 → 0.69.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.
@@ -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,
@@ -876,17 +799,17 @@ module Samagotchi
                                                        cwd: session.working_directory),
           failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
-          queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
+          queued: snapshot_list(turn_snapshot, "queued"),
           # Commands waiting for the running turn's end (their bubbles).
-          queued_commands: turn_snapshot ? Array(turn_snapshot["queued_commands"]) : [],
+          queued_commands: snapshot_list(turn_snapshot, "queued_commands"),
           recap: turn_snapshot && turn_snapshot["recap"],
           saved_recap: saved_recap_for(id, session, turn_snapshot),
           continue_offer: turn_snapshot && turn_snapshot["continue_offer"],
           guardrail_warning: turn_snapshot && turn_snapshot["guardrail_warning"],
           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)),
+          init_tasks: snapshot_list(turn_snapshot, "init_tasks"),
+          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,58 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # A list in the worker's turn +snapshot+ (queued prompts, commands,
+      # init tasks); [] without a worker.
+      def snapshot_list(snapshot, key) = Array(snapshot&.[](key))
+
+      # 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 +886,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
@@ -931,17 +906,18 @@ module Samagotchi
         turn_id = nil if turn_id.empty?
         tail = live_tail(id, turn_id: turn_id)
         state = tail && tail["session_state_snapshot"]
-        if state.is_a?(Hash)
-          session_json = { id: id, status: state["status"], used_memory_names: Array(state["used_memory_names"]),
-                           prompt_notes: Array(state["prompt_notes"]) }
+        state = nil unless state.is_a?(Hash)
+        if state
+          status, used, notes = state.values_at("status", "used_memory_names", "prompt_notes")
           messages = last_assistant_for_display([tail["answer"]].compact)
         else
           session = @session_class.load(id, state_dir: default_state_dir)
-          state = nil
-          session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names),
-                           prompt_notes: session.prompt_notes.map(&:to_h) }
+          status = displayed_status(session)
+          used = session.used_memory_names
+          notes = session.prompt_notes.map(&:to_h)
           messages = last_assistant_for_display(session.messages, turn_id: turn_id, cwd: session.working_directory)
         end
+        session_json = { id: id, status: status, used_memory_names: Array(used), prompt_notes: Array(notes) }
         live_metrics = state && state["metrics"]
         # Without recent=1: a tab opened before this release (it replaces its
         # timing with the reply's). Remove this branch after the next release.

data/lib/samagotchi/web/message_parts.rb

@@ -234,12 +234,15 @@ module Samagotchi
       # +tool_id+: its output's ToolIds id, with its ✂ mark in +marks+.
       def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil, refs: nil, cwd: nil,
                     tool_id: nil, marks: {})
+        # A built-in reached through call_tool reloads as that built-in's
+        # row, with via (its saved params and label are the built-in's).
+        call = Tools::BuiltinCalls.unwrap_saved(call, output)
         name = call[:name].to_s
         params = shown.is_a?(String) ? shown : ToolActivity.tool_activity_params(name, call, registry: registry)
         part = { tool: name, params: params.to_s }
-        # Its row fields (ToolRowFields: title, called_as, view, ref), built from the saved
+        # Its row fields (ToolRowFields: title, called_as, via, view, ref), built from the saved
         # call (never saved themselves), so older sessions get them too. The
-        # saved call is rebuilt by BuiltinCalls, which sets called_as again.
+        # saved call is rebuilt by BuiltinCalls, which sets called_as and via again.
         part.merge!(ToolRowFields.for(name, call, cwd: cwd))
         part[:label] = label if label.is_a?(String) && !label.empty?
         unless output.nil?

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

@@ -40,6 +40,8 @@ export function newActivity() {
 //     it in place of the params when there is one.
 //   called_as: the name the model called the tool by when it was an
 //     alias's ("bash" run as execute); the row says so.
+//   via: the tool it was reached through ("call_tool": a built-in the
+//     session's toolkit doesn't declare); the row says so.
 //   view: the call's full arguments for the expanded row and the hovers
 //     (the server's ToolView: an execute/task_create's command, its cwd).
 //   ref: what the row traces to (the server's FileRef: {kind: "file",
@@ -48,7 +50,7 @@ export function newActivity() {
 //   refs: a plugin tool's refs (the server's RowRefs: [{kind, target,
 //     label?, actions}]): the first on the row's title, the others in its
 //     menu (refs.js bindRowRefs).
-export const ACTIVITY_FIELDS = Object.freeze(["title", "called_as"]);
+export const ACTIVITY_FIELDS = Object.freeze(["title", "called_as", "via"]);
 export const EVENT_FIELDS = Object.freeze(["view", "ref", "refs"]);
 const ROW_FIELDS = Object.freeze([...ACTIVITY_FIELDS, ...EVENT_FIELDS]);