samagotchi 0.16.0 → 0.18.0

data/lib/samagotchi/web/app.rb

@@ -9,11 +9,13 @@ require "uri"
 require "rack"
 require "rack/request"
 
+require_relative "../answer_tail"
 require_relative "../bridge_client"
 require_relative "../bridge/bounded_queue"
 require_relative "../bridge/card_store"
 require_relative "../session"
 require_relative "../session_manager"
+require_relative "../session_metrics"
 require_relative "../session_commands"
 require_relative "../steer"
 require_relative "../host_registry"
@@ -177,14 +179,18 @@ module Samagotchi
 
       # API requests at debug level (not the page and its assets): method,
       # path, status, time. Never a body or the query; only a tail=1 read
-      # (the page's end-of-turn re-read) is marked, to tell it from a full one.
+      # (the page's end-of-turn re-read) and a timing=1 one (its fallback
+      # when the merge came up short) are marked, to tell them from a full one.
       def log_request(env, response, started)
         path = env["PATH_INFO"].to_s
         return unless path.start_with?("/api/") && Log.level?(:debug)
 
-        tail = env["QUERY_STRING"].to_s.split("&").include?("tail=1") ? { tail: true } : {}
+        params = env["QUERY_STRING"].to_s.split("&")
+        marks = {}
+        marks[:tail] = true if params.include?("tail=1")
+        marks[:timing] = true if params.include?("timing=1")
         Log.debug(:web, "request", sid: path[%r{\A/api/sessions/([^/]+)}, 1], method: env["REQUEST_METHOD"], path: path,
-                                   status: response[0], **tail,
+                                   status: response[0], **marks,
                                    ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       end
 
@@ -518,6 +524,11 @@ module Samagotchi
       end
 
       def handle_show(req, id)
+        # The page's light re-reads: never the whole conversation.
+        return handle_cards_read(id) if req.params["cards"] == "1"
+        return handle_tail_read(req, id) if req.params["tail"] == "1"
+        return handle_timing_read(id) if req.params["timing"] == "1"
+
         session = @session_class.load(id, state_dir: default_state_dir)
         # Read-only preview: selecting a session never spawns a worker.
         # The worker is woken only on POST /turn (handle_turn) via
@@ -531,11 +542,6 @@ module Samagotchi
         # behind it, all at one event_seq the client streams on from.
         live = bridge_get_json(id, "snapshot")
         turn_snapshot = live && live["snapshot"]
-        # ?cards=1: the page's re-read when a card arrives, for its rendered
-        # body (the stream carries the card's plain text only).
-        if req.params["cards"] == "1"
-          return json_response(200, { cards: cards_for_display(turn_snapshot, id) })
-        end
         snapshot = live && live["session_state_snapshot"]
         last_event_seq = snapshot ? snapshot["event_seq"] : bridge_event_seq(id)
         current_turn = turn_snapshot && turn_snapshot["current_turn"]
@@ -543,8 +549,9 @@ module Samagotchi
         # 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"]
+                    current_turn ? current_turn["pending_question"] : turn_snapshot["pending_question"]
                   elsif owner&.worker?
                     session.pending_question
                   end
@@ -557,19 +564,6 @@ module Samagotchi
         end
         raw_messages = turn_snapshot ? turn_snapshot["messages"] : session.messages
         timing = timing_payload(id, live_metrics: snapshot && snapshot["metrics"])
-        # ?tail=1: the page's re-read at the end of a turn wants the final
-        # answer's rendered markdown, the status and the timing, not the
-        # whole history again (nor a render of every earlier answer).
-        if req.params["tail"] == "1"
-          return json_response(200, {
-            tail: true,
-            session: session_json,
-            messages: last_assistant_for_display(raw_messages),
-            markdown_warning: @markdown_renderer.warning,
-            timing: timing
-          })
-        end
-
         json_response(200, {
           session: session_json,
           history: read_history(id),
@@ -585,7 +579,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, id),
+          cards: cards_for_display(turn_snapshot ? 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,
@@ -601,14 +595,101 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       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
+      # is only stat'ed (the 404), never parsed.
+      def handle_cards_read(id)
+        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)) })
+      end
+
+      # ?tail=1: the page's re-read at the end of a turn wants the final
+      # answer's rendered markdown, the status and the timing, not the whole
+      # history again (nor a render of every earlier answer). Live: the
+      # worker's GET tail alone (no session file read); else the file. The
+      # session part is what the page reads of it (id, status, used memory
+      # names). ?turn_id=: that turn's answer (a queued turn's page re-reads
+      # after the next one started). ?recent=1 (the page since this
+      # release): the timing's records are the newest turn's (#recent_timing),
+      # which the page merges by id; without it, the whole timing as before.
+      def handle_tail_read(req, id)
+        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+
+        turn_id = req.params["turn_id"].to_s.strip
+        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"]) }
+          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) }
+          messages = last_assistant_for_display(session.messages, turn_id: turn_id)
+        end
+        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.
+        timing = req.params["recent"] == "1" ? recent_timing(id, live_metrics) : timing_payload(id, live_metrics: live_metrics)
+        json_response(200, {
+          tail: true,
+          session: session_json,
+          messages: messages,
+          markdown_warning: @markdown_renderer.warning,
+          timing: timing
+        })
+      rescue ArgumentError => e
+        error_response(404, "not_found", e.message)
+      end
+
+      # ?timing=1: the whole timing (every record, analytics.json merged with
+      # the live ones) and turn_count, when the page's merge comes up short.
+      # The worker's GET state, never its messages.
+      def handle_timing_read(id)
+        return error_response(404, "not_found", "Session not found: #{id}") unless session_exists?(id)
+
+        state = bridge_get_json(id, "state")
+        json_response(200, { timing: timing_payload(id, live_metrics: state && state["session_state_snapshot"]&.fetch("metrics", nil)) })
+      end
+
+      def session_exists?(id)
+        @session_class.exist?(id, state_dir: default_state_dir)
+      rescue ArgumentError
+        false
+      end
+
+      # The worker's light read (Bridge GET tail): {"session_state_snapshot",
+      # "answer", "cards", "event_seq", "event_id"}. A worker from before the
+      # route answers 404 not_found: its GET snapshot, in the same shape (the
+      # answer by AnswerTail). Anything else (no worker, a refused connect, a
+      # 500, a timeout) is nil: the caller reads the disk, with no second
+      # try at a worker that failed once.
+      # @return [Hash, nil]
+      def live_tail(id, turn_id: nil)
+        status, body = bridge_get(id, turn_id ? "tail?turn_id=#{URI.encode_www_form_component(turn_id)}" : "tail")
+        return body if status == 200 && body.is_a?(Hash)
+        return nil unless status == 404 && body.is_a?(Hash) && body["error"] == "not_found"
+
+        status, live = bridge_get(id, "snapshot")
+        return nil unless status == 200 && live.is_a?(Hash) && live["snapshot"].is_a?(Hash)
+
+        snap = live["snapshot"]
+        { "session_state_snapshot" => live["session_state_snapshot"],
+          "answer" => AnswerTail.find(snap["messages"], turn_id: turn_id),
+          "cards" => snap["cards"], "event_seq" => snap["event_seq"], "event_id" => snap["event_id"] }
+      end
+
       # The worker's last cards and between-turns notices (Bridge
-      # snapshot[:cards]), else (no live worker) the ones the last worker
-      # saved in the session's folder (CardStore.saved), a card's body as
+      # cards: CardStore#list), else (no live worker) the ones the last
+      # worker saved in the session's folder (#saved_cards), a card's body as
       # body_html: rendered markdown when the renderer is on, else the
       # escaped text in a <pre>.
       # @return [Array<Hash>]
-      def cards_for_display(turn_snapshot, id)
-        cards = turn_snapshot ? turn_snapshot["cards"] : saved_cards(id)
+      def cards_for_display(cards)
         Array(cards).filter_map do |card|
           next unless card.is_a?(Hash)
           next card unless card["type"].to_s == "card"
@@ -979,7 +1060,8 @@ module Samagotchi
       end
 
       # GET /api/events: the session list as one SSE stream per tab. The
-      # first frame is the hub's snapshot (scoped by ?dir= as the list is),
+      # first frame is the hub's snapshot (scoped by ?dir= as the list is,
+      # with chi's version),
       # then `session` for an upsert and `session_gone` for a removal, with
       # a `: ping` while idle. Frame ids are the hub's seq, for the log's
       # sake: there is no replay, a reconnect starts with a fresh snapshot.
@@ -1059,12 +1141,22 @@ module Samagotchi
         port && BridgeClient.new(session_id: session_id, port: port, host: DEFAULT_HOST)
       end
 
-      # Read the live Engine state over the bridge (raw GET /session/:id/state).
+      # GET a read path of the session's live Bridge (+path+: "state",
+      # "snapshot", "stats", ...).
       # @return [Hash, nil] parsed JSON body, or nil when no live bridge / timeout.
       def bridge_get_json(session_id, path)
         bridge_client(session_id)&.get_json(path)
       end
 
+      # GET a read path of the session's live Bridge with its status
+      # (BridgeClient#get).
+      # @return [Array(Integer, Object)] [status, parsed body]; [nil, nil]
+      #   with no live bridge or no reply
+      def bridge_get(session_id, path)
+        client = bridge_client(session_id)
+        client ? client.get(path) : [nil, nil]
+      end
+
       # Monotonic SSE cursor for a live bridge session, else nil.
       def bridge_event_seq(session_id)
         bridge_client(session_id)&.event_seq
@@ -1137,9 +1229,12 @@ module Samagotchi
                                 session_dir: @session_class.session_dir(s.id, state_dir: default_state_dir))
       end
 
+      # The whole timing: analytics.json's records merged with a live
+      # worker's (by id), and turn_count, the finished turns (#turn_count).
       def timing_payload(session_id, live_metrics: nil)
         persisted = read_analytics(session_id)
-        source = if live_metrics.is_a?(Hash)
+        live = live_metrics.is_a?(Hash)
+        source = if live
                    persisted.merge(live_metrics).merge(
                      "started_at" => persisted["started_at"] || live_metrics["started_at"],
                      "turn_records" => merge_timing_records(persisted["turn_records"], live_metrics["turn_records"]),
@@ -1148,14 +1243,66 @@ module Samagotchi
                  else
                    persisted
                  end
+        turns = Array(source["turn_records"])
+        timing_from(source, turns, Array(source["tool_records"]), live: live,
+                                                                 turn_count: (live && turn_count(live_metrics)) || turns.size)
+      end
+
+      # The timing a ?tail=1&recent=1 read sends: a live worker's recent
+      # records as its metrics hold them (the newest finished turn's and
+      # the unsaved ones, the running turn's finished calls), no
+      # analytics.json read; with no worker the disk's, trimmed to the
+      # newest turn. turn_count tells the page whether its merge missed one
+      # (it then reads ?timing=1).
+      def recent_timing(session_id, live_metrics)
+        if live_metrics.is_a?(Hash)
+          count = turn_count(live_metrics)
+          # A metrics hash without the count: the whole timing.
+          return timing_payload(session_id, live_metrics: live_metrics) unless count
+
+          turns = Array(live_metrics["turn_records"])
+          tools = Array(live_metrics["tool_records"])
+          # An older worker's metrics hold every record (before they held the
+          # recent ones only, never more than LIVE_RECORDS_CAP turns).
+          turns, tools = newest_turn_records(turns, tools, live_metrics["active_turn"]) if turns.size > SessionMetrics::LIVE_RECORDS_CAP
+          return timing_from(live_metrics, turns, tools, live: true, turn_count: count)
+        end
+
+        persisted = read_analytics(session_id)
+        all = Array(persisted["turn_records"])
+        turns, tools = newest_turn_records(all, Array(persisted["tool_records"]), nil)
+        timing_from(persisted, turns, tools, live: false, turn_count: all.size)
+      end
+
+      # The finished turns a live worker counts: its metrics' turns (the
+      # loaded history, its own and the running one) less the running one.
+      # @return [Integer, nil]
+      def turn_count(metrics)
+        turns = metrics["turns"]
+        return nil unless turns.is_a?(Integer)
+
+        [turns - (metrics["active_turn"] ? 1 : 0), 0].max
+      end
+
+      # The newest turn record and its tool records (and the running turn's
+      # finished calls).
+      def newest_turn_records(turns, tools, active_turn)
+        kept = turns.last(1)
+        ids = kept.filter_map { |r| r["id"] if r.is_a?(Hash) }
+        ids << active_turn["id"] if active_turn.is_a?(Hash) && active_turn["id"]
+        [kept, tools.select { |r| r.is_a?(Hash) && ids.include?(r["turn_id"]) }]
+      end
+
+      def timing_from(source, turn_records, tool_records, live:, turn_count:)
         started_at = source["started_at"]
         last_activity_at = source["last_activity_at"]
         {
           started_at: started_at,
           last_activity_at: last_activity_at,
-          session_duration_ms: session_duration_ms(started_at, last_activity_at, active: live_metrics.is_a?(Hash)),
-          turn_records: Array(source["turn_records"]),
-          tool_records: Array(source["tool_records"]),
+          session_duration_ms: session_duration_ms(started_at, last_activity_at, active: live),
+          turn_records: turn_records,
+          tool_records: tool_records,
+          turn_count: turn_count,
           active_turn: source["active_turn"],
           active_tools: Array(source["active_tools"]),
           # The context last seen and the token sums, for the ctx meter
@@ -1331,14 +1478,10 @@ module Samagotchi
         MessageParts.for_message(list[index], responses, cwd: cwd)
       end
 
-      # The last message messages_for_display shows as an answer, as a list of
-      # at most one: walked backwards so only that one is rendered.
-      def last_assistant_for_display(msgs)
-        Array(msgs).reverse_each do |m|
-          shown = messages_for_display([m]).first
-          return [shown] if shown && shown[:role] == "assistant"
-        end
-        []
+      # The last message messages_for_display shows as an answer
+      # (AnswerTail), as a list of at most one: only that one is rendered.
+      def last_assistant_for_display(msgs, turn_id: nil)
+        messages_for_display([AnswerTail.find(msgs, turn_id: turn_id)].compact)
       end
 
       def parse_json(str)
@@ -1383,7 +1526,9 @@ module Samagotchi
       # folder in a repo, that project's name and root. A bad dir adds
       # nothing here: the list call answers 400 and the page says so.
       def index_data_attributes(req)
-        attrs = { "sessions-dir" => sessions_dir_label, "server-dir" => home_label(Dir.pwd) }
+        # version: the chi that served the page; the events snapshot names
+        # the one serving now (an upgraded chi web after a reconnect).
+        attrs = { "sessions-dir" => sessions_dir_label, "server-dir" => home_label(Dir.pwd), "version" => Samagotchi::VERSION }
         attrs["view"] = view_name(req.params["view"])
         # Always there: an empty one means no presets, not the default.
         attrs["annotate-presets"] = @annotate_presets
@@ -1456,7 +1601,8 @@ module Samagotchi
         end
 
         def each
-          yield frame(nil, "snapshot", sessions: @snapshot)
+          # version: the page compares it with the one it was served by.
+          yield frame(nil, "snapshot", sessions: @snapshot, version: Samagotchi::VERSION)
           last_write = monotonic
           loop do
             event = @queue.pop([@heartbeat, EVENTS_POLL].min)