samagotchi 0.30.0 → 0.31.0

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

@@ -93,7 +93,13 @@ export function isOwn(clientId, myId) {
 
 // As the TUI labels them (Formatting::CLIENT_LABELS); this file's label
 // helpers and the TUI's agree per spec/shared/labels_matrix.json.
-const CLIENT_LABELS = Object.freeze({ tui: "tui", web: "web", system: "reminder", delegate: "delegate" });
+const CLIENT_LABELS = Object.freeze({ tui: "tui", web: "web", system: "reminder", delegate: "delegate", child: "delegate report" });
+
+// A delegate child's report comes in as client child:<id8> (ChildReports).
+const REPORT_CLIENT = "child:";
+export function isReportClient(clientId) {
+  return String(clientId || "").startsWith(REPORT_CLIENT);
+}
 
 // The label on another client's prompt, by its client_id prefix.
 export function clientLabel(clientId) {
@@ -119,9 +125,10 @@ export function hookNoticeLabel(hook) {
 }
 
 // The row a step gets when the loop asks again after an empty answer, or
-// after a plugin cut the generation (stopped_by: the bundle).
-export function emptyRetryLine({ attempt, of, stopped_by: stoppedBy } = {}) {
-  const what = stoppedBy ? `cut by ${stoppedBy}` : "empty answer";
+// after a plugin cut the generation (stopped_by: the bundle), or after a
+// corrupt native generation (malformed).
+export function emptyRetryLine({ attempt, of, stopped_by: stoppedBy, malformed } = {}) {
+  const what = stoppedBy ? `cut by ${stoppedBy}` : malformed ? "malformed answer" : "empty answer";
   return `↻ ${what}, asking again (${attempt}/${of})`;
 }
 
@@ -381,9 +388,14 @@ export function composerAfterAck({ sent = "", current = "", refill = "" } = {})
 //   tag   — this tab's own local echo gets its enqueued_id
 //   start — the bubble's turn started (drops the "queued" badge)
 //   steer — the bubble was merged into the running turn
+//   report — the merge brought a delegate child's report (origin
+//           child:<id8>, no bubble anywhere): its text gets a labelled one
 // `known(enqueuedId)` says whether a bubble carries that id already;
-// `unmatchedMerge` whether the last input_merged had an origin with no bubble.
-export function promptOps(event, { myId, known, unmatchedMerge = false }) {
+// `unmatchedMerge` whether the last input_merged had an origin with no
+// bubble ("report": a delegate report's); `wakeStart` whether this is the
+// first merge of a turn chi ran for reports (its bubble starts the turn,
+// no "steered" badge, as a reload shows it).
+export function promptOps(event, { myId, known, unmatchedMerge = false, wakeStart = false }) {
   if (!event) return [];
   switch (event.type) {
     case "turn_enqueued": {
@@ -403,12 +415,18 @@ export function promptOps(event, { myId, known, unmatchedMerge = false }) {
       }
       return [withImages({ op: "add", enqueuedId: id, prompt: event.prompt, state: "started", label: clientLabel(origin.client_id) }, event.images)];
     }
-    case "input_merged":
-      return (event.origins || []).filter((o) => o && o.enqueued_id).map((o) =>
+    case "input_merged": {
+      const ops = (event.origins || []).filter((o) => o && o.enqueued_id).map((o) =>
         known(o.enqueued_id) ? { op: "steer", enqueuedId: o.enqueued_id } : { op: "steer", enqueuedId: o.enqueued_id, unmatched: true },
       );
+      if ((event.origins || []).some((o) => o && !o.enqueued_id && isReportClient(o.client_id))) ops.push({ op: "report" });
+      return ops;
+    }
     case "pending_input_merged":
       if (!unmatchedMerge || !event.content) return [];
+      if (unmatchedMerge === "report") {
+        return [{ op: "add", enqueuedId: null, prompt: event.content, state: wakeStart ? null : "steered", label: clientLabel(REPORT_CLIENT) }];
+      }
       return [{ op: "add", enqueuedId: null, prompt: event.content, state: "steered", label: null }];
     default:
       return [];

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

@@ -14,7 +14,7 @@ import { leavesBlock } from "./card.js";
 import { copySourceAttr } from "./copy.js";
 import { commandBlockHtml, rowHover } from "./command_view.js";
 import { activityDiffHtml } from "./diff_view.js";
-import { escapeHtml, messageBodyHtml, noteHtml, normalize, steerRowHtml } from "./format.js";
+import { escapeHtml, messageBodyHtml, noteHtml, normalize, sourceLabel, steerRowHtml } from "./format.js";
 import { thumbsHtml } from "./images.js";
 import { shouldFollowScroll } from "./scroll.js";
 import { emptyAnswerLine, hookNoticeLabel } from "./turn_events.js";
@@ -805,13 +805,28 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const { body, renderedMarkdown } = messageBodyHtml(m);
     return `<div class="bubble output${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(m, renderedMarkdown)}>${body}</div>${timing}`;
   };
+  // The live bubble's origin label (app.js makeUserBubble), for a line
+  // chi brought in: a delegate report.
+  const originLabelHtml = (m) => {
+    const label = sourceLabel(m?.source);
+    return label ? `<span class="origin-label">${escapeHtml(label)}</span>` : "";
+  };
+  // The first text after a delegate report merged mid-turn, unless it is
+  // the turn's answer (shown anyway).
+  const reportReplyHtml = (i, group) => {
+    if (items[i]?.source !== "delegate_report") return "";
+    const j = items.findIndex((m, k) => k > i && m?.role === "assistant" && String(m.content ?? "").trim());
+    if (j < 0 || j === group.answer || items.slice(i + 1, j).some((m) => m?.role === "user" && !m.merged)) return "";
+    const { body, renderedMarkdown } = messageBodyHtml(items[j]);
+    return `<div class="bubble output report-reply${renderedMarkdown ? " markdown" : ""}"${copySourceAttr(items[j], renderedMarkdown)}>${body}</div>`;
+  };
   const steerHtml = (i, bubble) => steerRowHtml({ source: items[i].source, text: items[i].content }, { bubble });
   return turnGroups(items, timing).map((group) => {
     if (group.kind === "note") return `<div class="bubble note">${noteHtml(items[group.i])}</div>`;
     if (group.kind === "steer") return steerHtml(group.i, true);
     if (group.kind === "answer") return answerHtml(items[group.answer], "");
     const prompt = items[group.user];
-    const parts = [`<div class="bubble user"${copySourceAttr(prompt, false)}><div class="user-message">${messageBodyHtml(prompt).body}${thumbs(prompt.images)}</div></div>`];
+    const parts = [`<div class="bubble user"${copySourceAttr(prompt, false)}>${originLabelHtml(prompt)}<div class="user-message">${messageBodyHtml(prompt).body}${thumbs(prompt.images)}</div></div>`];
     const [only] = group.steps;
     const ended = group.answer !== null || group.emptyAnswer != null;
     const textless = only && (only.i === null || !String(items[only.i].content ?? ""));
@@ -843,9 +858,13 @@ export function turnHistoryHtml(items, timing, { thumbs }) {
     const loose = noBlock ? [...group.steps.flatMap((step) => step.steers || []), ...(group.steers || [])] : group.steers || [];
     parts.push(loose.map((i) => steerHtml(i, true)).join(""));
     // The user's lines merged into the turn: the live "steered" bubbles,
-    // after its steps and before its answer.
+    // after its steps and before its answer. A delegate report's is
+    // followed by the text that answered it when that isn't the answer: a
+    // small model tells its user about a report before its next tool call,
+    // and that step's text would stay folded in the block.
     parts.push((group.merged || []).map((i) =>
-      `<div class="bubble user steered" data-user-state="steered"${items[i].step ? ` data-step="${Number(items[i].step)}"` : ""}${copySourceAttr(items[i], false)}><div class="user-message">${messageBodyHtml(items[i]).body}${thumbs(items[i].images)}</div><span class="state-badge">steered</span></div>`).join(""));
+      `<div class="bubble user steered" data-user-state="steered"${items[i].step ? ` data-step="${Number(items[i].step)}"` : ""}${copySourceAttr(items[i], false)}>${originLabelHtml(items[i])}<div class="user-message">${messageBodyHtml(items[i]).body}${thumbs(items[i].images)}</div><span class="state-badge">steered</span></div>` +
+      reportReplyHtml(i, group)).join(""));
     // A turn that ended with no answer: chi's muted notice where the answer
     // would be, before the timing, as live.
     if (group.emptyAnswer != null) parts.push(`${emptyAnswerHtml(items[group.emptyAnswer])}${timingHtml(group)}`);

data/lib/samagotchi/worker.rb

@@ -17,6 +17,7 @@ require_relative "continue_offer"
 require_relative "iteration_limit"
 require_relative "session_commands"
 require_relative "model_profile"
+require_relative "child_reports"
 require_relative "tools/task_runtime"
 
 module Samagotchi
@@ -45,6 +46,11 @@ module Samagotchi
   # turn) is refused as busy.
   class Worker
     FALLBACK_TICK_SECONDS = 5
+    # A worker just started runs no wake turn for delegate reports this
+    # long: a worker spawned for a message (chi send to a stopped parent)
+    # gets it over the Bridge a moment after it starts, and that message's
+    # turn goes first (the reports join it).
+    WAKE_START_GRACE = 2.0
     # How much of a command's output goes into its :command_ran.
     COMMAND_OUTPUT_LIMIT = 4096
     BUSY_OUTPUT = "busy: wait for the turn to end"
@@ -89,6 +95,25 @@ module Samagotchi
       @discard = false
       # The exit asked for is a restart (POST /exit restart: true).
       @exit_restart = false
+      # The lines the running turn's drain merged ([prompt, origin]), for a
+      # failed prompt turn to hand back; reset as each turn begins.
+      @merged_this_turn = []
+      # A delegate child's side (ChildRing): whether the running turn is
+      # its parent's (it rings when it ends), whether that turn rang a
+      # question, and whether the next turn rings whatever its origin (it
+      # follows a question the parent was rung about: D10).
+      @reporting_turn = false
+      @asked_parent = false
+      @owes_parent = false
+      @initial_turn = false
+      # A parent's side: turns run for delegate reports since the last human
+      # input (session.max_wakes), whether a failed one paused them until
+      # then, whether the budget notice went out, and the reports a wake
+      # turn's first boundary hands over.
+      @wakes_in_a_row = 0
+      @wakes_paused = false
+      @budget_noticed = false
+      @wake_reports = nil
     end
 
     # Whether the session was empty as the worker left it, so the caller
@@ -96,6 +121,12 @@ module Samagotchi
     # checks again then).
     def discard? = @discard
 
+    # Whether delegate reports wait that an idle parent runs a turn for
+    # (#wake_state): SessionManager.run_session_loop starts a new worker
+    # for them after this one leaves. Reports the budget or a failure held
+    # back wait for the next human input instead.
+    def wake_due? = wake_state == :due
+
     # What a new session starts on (and /model resets to); nil before #run.
     attr_reader :default_model
 
@@ -105,6 +136,7 @@ module Samagotchi
     #   (chi stop), :crashed when the loop raised (the session is marked
     #   errored); SessionManager.run_session_loop turns it into the exit
     def run
+      @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       @session = Session.load(@session_id, state_dir: @state_dir)
       drop_dead_question
       @engine = build_engine
@@ -114,7 +146,7 @@ module Samagotchi
       @engine.session = @session
       # Input already waiting in the inbox starts the next turn at once: no
       # turn-end warm-up then.
-      @engine.next_turn_waiting = -> { SessionInbox.find_new_input_files(@session_dir).any? }
+      @engine.next_turn_waiting = -> { SessionInbox.find_new_input_files(@session_dir).any? || wake_due? }
       @turn_flow = TurnFlow.new(engine: @engine)
       # Its question's answer is queued as the matching /continue (the
       # Bridge exists by the time anyone answers).
@@ -131,7 +163,11 @@ module Samagotchi
       @turn_end_seq = 0
       @engine.subscribe(observer: lambda { |event|
         @turn_end_seq = event[:event_seq] if Events::TURN_END.include?(event[:type])
+        @turn_id = event[:turn_id] if event[:type] == :turn_started
+        ring_question(event) if event[:type] == :question_requested
       })
+      # This session's own delegate children's news (rings in children/).
+      @child_reports = ChildReports.new(session_id: @session_id, state_dir: @state_dir)
       # /model's default is the config's, as in the REPL; the Engine started
       # on the session's model.
       @default_model = ModelProfile.required_model_name(nil)
@@ -190,17 +226,18 @@ module Samagotchi
           absorb_notes
 
           if (prompt = take_initial_prompt)
-            run_prompt(prompt, nil) unless initial_command(prompt)
+            run_initial_prompt(prompt) unless initial_command(prompt)
             next
           end
 
           input_files = SessionInbox.find_new_input_files(@session_dir)
           if input_files.empty?
+            next if run_wake_turn
             next if run_due_reminders
             return left(:idle_exit) if @idle_exit.due? && leave_idle
             return left(@exit_restart ? :restart : :exit_requested) if @exit_requested && leave_on_request
 
-            @waker.wait(@poll_interval)
+            @waker.wait(idle_wait)
             next
           end
 
@@ -216,6 +253,8 @@ module Samagotchi
         # Its stderr is /dev/null: the log is the only trace of why.
         Log.exception(:worker, "crashed", e)
         Session.mark_error(@session_id, reason: e.message, state_dir: @state_dir)
+        # A delegate's parent hears of it (best effort).
+        ChildRing.ring(@session, why: "crash", state_dir: @state_dir) if @session
         :crashed
       ensure
         # The anytime commands finish and the plugins' services stop (a
@@ -333,6 +372,15 @@ module Samagotchi
       claimed.each { |file| FileUtils.rm_f(file) }
     end
 
+    # The first prompt (spawn_session's): a delegate child's task, which is
+    # its parent's although no client sent it.
+    def run_initial_prompt(prompt)
+      @initial_turn = true
+      run_prompt(prompt, nil)
+    ensure
+      @initial_turn = false
+    end
+
     def run_input_file(input_file)
       claimed_file = SessionInbox.claim_input_file(input_file)
       return unless claimed_file
@@ -355,7 +403,6 @@ module Samagotchi
       user_input(origin&.dig(:client_id))
       @continue_offer.drop(origin)
       @turn_flow.before_prompt_turn
-      @merged_this_turn = []
       run_engine_turn(prompt, origin: origin, max_iterations: max_iterations(no_interrupt),
                               images: images) do |result, error|
         if error
@@ -387,6 +434,85 @@ module Samagotchi
       true
     end
 
+    # :due when an idle parent should run a turn for its delegate
+    # children's reports now (session.delegate_reports: wake): rings wait,
+    # no continue offer does (they merge into its turn), wakes aren't paused
+    # by a failed one, and the wake budget isn't spent; :budget when only
+    # the budget stops it; nil otherwise.
+    def wake_state
+      return nil unless @child_reports && ChildRing.mode == "wake"
+      return nil if @wakes_paused || @turn_flow&.awaiting_continue?
+      return nil unless @child_reports.waiting?
+
+      @wakes_in_a_row < max_wakes ? :due : :budget
+    end
+
+    # Run a turn nobody typed for the reports the rings bring (a wake turn):
+    # a continue turn (no prompt bubble) whose first boundary merges them,
+    # with origin child:<id8>. A failure goes back to the checkpoint, keeps
+    # the rings and pauses wakes until a human's input (a provider outage
+    # doesn't loop).
+    # @return [Boolean] whether a wake turn ran
+    def run_wake_turn
+      return false if wake_grace_left.positive?
+
+      state = wake_state
+      budget_notice if state == :budget
+      return false unless state == :due
+
+      reports, = take_child_reports
+      # The turn must not generate with nothing to say: the drain gets this
+      # exact list at its first boundary.
+      return false if reports.empty?
+
+      @wake_reports = reports
+      @wakes_in_a_row += 1
+      Log.info(:worker, "delegate_wake_turn", reports: reports.size, in_a_row: @wakes_in_a_row)
+      @turn_flow.before_prompt_turn
+      run_engine_turn(nil, continue: true, origin: reports.first.origin, max_iterations: IterationLimit.for) do |result, error|
+        if error
+          note = TurnNote.failed(error.respond_to?(:summary) ? error.summary : error.message)
+          @turn_flow.prompt_turn_failed(note: note)
+          @wakes_paused = true
+        else
+          @continue_offer.after_turn(result)
+        end
+      end
+      true
+    ensure
+      @wake_reports = nil
+    end
+
+    def wake_grace_left
+      WAKE_START_GRACE - (Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at)
+    end
+
+    # The idle loop's sleep: the fallback tick, or less while reports wait
+    # out the start grace.
+    def idle_wait
+      left = wake_grace_left
+      left.positive? && wake_state == :due ? [left, @poll_interval].min : @poll_interval
+    end
+
+    def max_wakes
+      value = Integer(Config.get(ChildRing::MAX_WAKES_KEY), exception: false)
+      value&.positive? ? value : ChildRing::MAX_WAKES_DEFAULT
+    rescue StandardError
+      ChildRing::MAX_WAKES_DEFAULT
+    end
+
+    # The wake budget is spent: the parent's UIs hear once that reports
+    # wait for the next message.
+    def budget_notice
+      return if @budget_noticed
+
+      @budget_noticed = true
+      count = SessionInbox.find_ring_files(@session_dir).map { |f| SessionInbox.read_ring(f)&.dig(:child_id) }.uniq.size
+      @engine.announce(type: :hook_notice, hook: "delegate", level: :info, between_turns: true,
+                       text: "#{count} delegate report#{"s" if count != 1} waiting; #{count == 1 ? "it joins" : "they join"} " \
+                             "your next message (#{max_wakes} turn#{"s" if max_wakes != 1} ran for reports in a row, #{ChildRing::MAX_WAKES_KEY})")
+    end
+
     def max_iterations(no_interrupt) = IterationLimit.for(no_interrupt: no_interrupt)
 
     # @return [Boolean] whether any command ran
@@ -496,6 +622,10 @@ module Samagotchi
     # @yieldparam result [Object, nil] Engine#run_turn's, nil on a failure
     # @yieldparam error [StandardError, nil]
     def run_engine_turn(prompt, **turn_args)
+      # Every kind of turn merges steering (a reminder turn too, which may be
+      # a fresh worker's first), so the list is this turn's from the start.
+      @merged_this_turn = []
+      @reporting_turn = reports_to_parent?(turn_args[:origin])
       begin
         @session.status = Session::STATUS_RUNNING
         @session.save(state_dir: @state_dir)
@@ -519,6 +649,51 @@ module Samagotchi
         SessionInbox.write_output(@session_dir, response)
       end
       save_or_log(:turn) { save_session }
+      settle_child_reports(error)
+      ring_parent_after_turn
+    end
+
+    # The delegate reports this turn took: a kept turn moves the cursors on
+    # and deletes their rings; a failed one (rolled back) leaves the rings
+    # for the next turn.
+    def settle_child_reports(error)
+      error ? @child_reports.release : @child_reports.commit
+    end
+
+    # A delegate child's turn that was its parent's (#reports_to_parent?)
+    # rings the parent, after the save: the parent reads a settled child.
+    # A question it rang about that still waits makes the next turn ring
+    # too, whoever starts it (the user answering Continue on the web).
+    def ring_parent_after_turn
+      ChildRing.ring(@session, why: "turn_end", state_dir: @state_dir) if @reporting_turn
+      @owes_parent = @asked_parent && !@session.pending_question.nil?
+      @asked_parent = false
+      @reporting_turn = false
+    end
+
+    # Whether the turn starting now is a delegate child's parent's: its
+    # task (the initial prompt), a follow-up, a continue the parent
+    # answered, a reminder, anything but a human typing into the child
+    # (ArchiveStore.user_input?), and any turn after a question the parent
+    # was rung about.
+    def reports_to_parent?(origin)
+      return false unless @session.delegate?
+
+      @initial_turn || @owes_parent || !ArchiveStore.user_input?(origin&.dig(:client_id))
+    end
+
+    # The Engine published a question (after the question desk saved it).
+    # In a turn that reports to the parent, the model's own question and
+    # the step-limit continue ring it; approvals and hooks' questions are
+    # the user's, on this session's card.
+    def ring_question(event)
+      return unless @reporting_turn
+
+      kind = event.dig(:pending_question, :kind).to_s
+      return unless ["", ContinueOffer::KIND].include?(kind)
+
+      ChildRing.ring(@session, why: "question", state_dir: @state_dir)
+      @asked_parent = true
     end
 
     # A save between turns (the turn's own, a command's, the notes', the
@@ -588,14 +763,42 @@ module Samagotchi
           end
         end
         merged.each { |_prompt, origin| user_input(origin&.dig(:client_id)) }
-        unless merged.empty?
-          @engine.announce(type: :input_merged, count: merged.size, origins: merged.filter_map(&:last))
+        # Delegate children's reports: never handed back on a failure
+        # (their rings stay for the next turn), so not in @merged_this_turn.
+        reports, mark = take_child_reports
+        unless merged.empty? && reports.empty?
+          @engine.announce(type: :input_merged, count: merged.size + reports.size,
+                           origins: merged.filter_map(&:last) + reports.map(&:origin))
           @merged_this_turn.concat(merged)
         end
         # Each line keeps its sender (Steer.source_for_client): a chi send or
         # a delegating parent's line is saved and shown to the model as theirs.
-        merged.map { |prompt, origin| Steer::Line.new(text: prompt, source: Steer.source_for_client(origin&.dig(:client_id))) }
+        lines = merged.map { |prompt, origin| Steer::Line.new(text: prompt, source: Steer.source_for_client(origin&.dig(:client_id))) } +
+                reports.map(&:line)
+        # A wake turn starts with its first line, whoever sent it.
+        lines[0] = lines[0].with(mark: mark) if mark && lines.any?
+        lines
+      end
+    end
+
+    # The reports for rings that came in since the turn last looked. A
+    # failure to read them must not take the turn's steering with it.
+    # A wake turn's first call gets the reports it was started for (their
+    # message is the turn's start: turn_start, turn_id, so a reload shows
+    # the turn as its own).
+    # @return [Array(Array<ChildReports::Report>, Hash|nil)] the reports
+    #   and the mark of their message
+    def take_child_reports
+      if @wake_reports
+        reports = @wake_reports
+        @wake_reports = nil
+        return [reports, { turn_start: true, turn_id: @turn_id }.compact]
       end
+
+      [@child_reports.take, nil]
+    rescue StandardError => e
+      Log.warn(:worker, "delegate_reports_failed", error: e.class.name, msg: e.message)
+      [[], nil]
     end
 
     # Check again with the event log held, which the Bridge holds while it
@@ -696,8 +899,14 @@ module Samagotchi
 
     # A human's input (ArchiveStore.user_input?) un-archives the session;
     # a delegate's, a plugin's or a reminder's doesn't.
+    # It also resets the delegate-report wakes (budget and pause).
     def user_input(client_id)
-      ArchiveStore.user_input(@session_id, state_dir: @state_dir) if ArchiveStore.user_input?(client_id)
+      return unless ArchiveStore.user_input?(client_id)
+
+      ArchiveStore.user_input(@session_id, state_dir: @state_dir)
+      @wakes_in_a_row = 0
+      @wakes_paused = false
+      @budget_noticed = false
     end
 
     def stopped_on_disk?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -193,6 +193,7 @@ files:
 - lib/samagotchi/bundles/system/memory_guide.md
 - lib/samagotchi/bundles/system/self_map.md
 - lib/samagotchi/cancellation_controller.rb
+- lib/samagotchi/child_reports.rb
 - lib/samagotchi/cli/command.rb
 - lib/samagotchi/cli/exit.rb
 - lib/samagotchi/cli/flags.rb
@@ -394,6 +395,7 @@ files:
 - lib/samagotchi/tools/builtins.rb
 - lib/samagotchi/tools/cancel_reminder.rb
 - lib/samagotchi/tools/delegate.rb
+- lib/samagotchi/tools/delegate_cursor.rb
 - lib/samagotchi/tools/delegate_relay.rb
 - lib/samagotchi/tools/delegate_result.rb
 - lib/samagotchi/tools/delegate_wait.rb