samagotchi 0.15.0 → 0.17.0

data/lib/samagotchi/relay_verifier.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "session"
+require_relative "bridge_client"
+require_relative "worker_sidecar"
+require_relative "question_desk"
+require_relative "guardrails/parent_approvals"
+require_relative "log"
+
+module Samagotchi
+  # A child worker taking its parent's answer to a relayed approval. The
+  # POST that says "answered" carries no answer and no authority: this
+  # worker asks its parent session's live Bridge what the parent's relay
+  # holds (RelayDesk, which only the parent's question flow writes), and
+  # answers its own question with that, only when it is about this session
+  # and the question pending now, and is answered.
+  class RelayVerifier
+    # The client id a relayed answer is recorded with: relay:<parent8>.
+    CLIENT_PREFIX = "relay"
+
+    # @param engine [Engine] this (the child's) worker's Engine
+    def initialize(engine:, state_dir:, session_id:)
+      @engine = engine
+      @state_dir = state_dir
+      @session_id = session_id
+    end
+
+    # @return [Array(Hash, Integer, Hash)] headers, status, body: 200
+    #   answered, 409 no longer pending, 403 refused (a parent agent's allow
+    #   beyond this worker's guardrails.parent_approvals), 422
+    #   relay_unverified (logged; the question stays open)
+    def answer(relay_id:, question_id:)
+      parent_id = own_parent_id or return unverified("this session has no parent", relay_id)
+      relay = parent_relay(parent_id, relay_id) or return unverified("the parent has no such relay", relay_id)
+      return unverified("the relay is about another session", relay_id) unless relay["child_id"] == @session_id
+      return unverified("the relay is about another question", relay_id) unless relay["child_question_id"] == question_id
+      return unverified("the relay is #{relay["state"]}, not answered", relay_id) unless relay["state"] == "answered"
+
+      apply(relay, parent_id: parent_id, question_id: question_id, relay_id: relay_id)
+    end
+
+    private
+
+    def apply(relay, parent_id:, question_id:, relay_id:)
+      answer = relay["answer"].is_a?(Hash) ? relay["answer"] : {}
+      parent_agent = relay["by"] != "user"
+      client_id = "#{CLIENT_PREFIX}:#{parent_id[0, 8]}"
+      if answer["dismissed"]
+        return not_pending(question_id) unless @engine.cancel_question("dismissed", id: question_id)
+
+        log("relay_answered", relay_id, id: question_id, dismissed: true, by: relay["by"])
+        return [{}, 200, { status: "dismissed", question_id: question_id }]
+      end
+
+      selected = labels(answer["selected_indices"], question_id) or return unverified("the answer's option is out of range", relay_id)
+      result = @engine.answer_question(id: question_id, selected: selected, freeform: answer["freeform"],
+                                       client_id: client_id, parent_agent: parent_agent)
+      log("relay_answered", relay_id, id: question_id, by: relay["by"])
+      [{}, 200, { status: "answered", question_id: question_id, answer: result }]
+    rescue QuestionDesk::NotPending
+      not_pending(question_id)
+    rescue QuestionDesk::Refused => e
+      log("relay_refused", relay_id, id: question_id, reason: e.reason)
+      [{}, 403, { error: "parent_approval_refused", reason: e.reason.to_s,
+                  detail: Guardrails::ParentApprovals.message(e.reason) }]
+    rescue ArgumentError => e
+      unverified("the answer doesn't fit the question: #{e.message}", relay_id)
+    end
+
+    # The parent's option indices as this question's own labels (the
+    # parent's are relabelled; the order is the same). nil when one is out
+    # of range; [] for a freeform-only deny.
+    def labels(indices, question_id)
+      pending = @engine.pending_question
+      return [] unless pending && pending[:id].to_s == question_id
+
+      options = Array(pending[:options])
+      indices = Array(indices)
+      return nil unless indices.all? { |index| index.is_a?(Integer) && index >= 0 && index < options.size }
+
+      indices.map { |index| options[index] }
+    end
+
+    def own_parent_id
+      Session.load(@session_id, state_dir: @state_dir).parent_id
+    rescue ArgumentError
+      nil
+    end
+
+    # @return [Hash, nil] what the parent's live Bridge says about the relay
+    def parent_relay(parent_id, relay_id)
+      dir = Session.session_dir(parent_id, state_dir: @state_dir)
+      client = BridgeClient.discover(parent_id, session_dir: dir) or return nil
+      response = client.relay_status(relay_id)
+      response.ok? ? response.json : nil
+    rescue SystemCallError, IOError
+      nil
+    end
+
+    def not_pending(question_id)
+      [{}, 409, { error: "question_not_pending", detail: "no pending question #{question_id}" }]
+    end
+
+    def unverified(why, relay_id)
+      log("relay_unverified", relay_id, why: why)
+      [{}, 422, { error: "relay_unverified", detail: why }]
+    end
+
+    def log(event, relay_id, **fields)
+      Log.info(:bridge, event, sid: @session_id, relay: relay_id.to_s[0, 8], **fields)
+    end
+  end
+end

data/lib/samagotchi/relay_watcher.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "worker_sidecar"
+require_relative "log"
+
+module Samagotchi
+  # A child's look at its parent while its question is relayed there: when
+  # the parent's worker is gone, its relay card and RelayDesk went with it,
+  # so the question's relay mark is cleared (reason parent_gone) and its
+  # cards say "answer here" again. Outside the question desk: it clears a
+  # mark, never cancels the question. Stops once the question is no longer
+  # that relay's.
+  module RelayWatcher
+    INTERVAL = 2
+
+    module_function
+
+    # @param engine [Engine] the child's
+    # @param parent_dir [String] the parent session's folder (its sidecar)
+    # @param live [#call] whether the parent's worker is up
+    # @return [Thread]
+    def start(engine:, question_id:, relay_id:, parent_dir:, interval: INTERVAL,
+              live: -> { WorkerSidecar.live(parent_dir, unlink: false) })
+      Thread.new do
+        loop do
+          sleep(interval)
+          break unless relayed?(engine.pending_question, question_id, relay_id)
+          next if live.call
+
+          Log.info(:bridge, "relay_parent_gone", id: question_id)
+          engine.annotate_question(question_id, relayed_to: nil, reason: "parent_gone")
+          break
+        end
+      rescue StandardError => e
+        Log.warn(:bridge, "relay_watch_failed", error: e.class.name, message: e.message)
+      end.tap { |thread| thread.report_on_exception = false }
+    end
+
+    def relayed?(pending, question_id, relay_id)
+      relay = pending && pending[:relayed_to]
+      return false unless relay.is_a?(Hash) && pending[:id].to_s == question_id.to_s
+
+      (relay[:relay_id] || relay["relay_id"]).to_s == relay_id.to_s
+    end
+  end
+end

data/lib/samagotchi/reply_wait.rb

@@ -50,10 +50,13 @@ module Samagotchi
     #   a failure replaces the note and leaves the count as it was.
     # @param owner_grace [Numeric, nil] seconds with no live worker before
     #   :worker_gone (one that died before its rescue leaves it running)
+    # @param interject [#call, nil] called once a poll, before the sleep
+    #   (the delegate wait relays other children's approvals there); the
+    #   time it takes doesn't count against +timeout+
     # @return [Result]
     # @raise [ArgumentError] no such session
     def call(id, state_dir:, cursor:, timeout: nil, poll_interval: POLL_INTERVAL, cancelled: -> { false },
-             baseline: nil, owner_grace: nil)
+             baseline: nil, owner_grace: nil, interject: nil)
       deadline = timeout && (monotonic + timeout.to_f)
       seen_running = false
       gone_since = nil
@@ -104,6 +107,12 @@ module Samagotchi
 
         return Result.new(status: :timeout) if deadline && monotonic > deadline
 
+        if interject
+          started = monotonic
+          interject.call
+          deadline += monotonic - started if deadline
+          next if cancelled.call
+        end
         sleep(poll_interval)
       end
     end

data/lib/samagotchi/self_report.rb

@@ -7,6 +7,7 @@ require_relative "context_window"
 require_relative "session"
 require_relative "log_path"
 require_relative "model_profile"
+require_relative "model_overlay"
 require_relative "thinking"
 require_relative "served_model"
 require_relative "host_registry"
@@ -39,7 +40,8 @@ module Samagotchi
     end
 
     def fields(env: ENV)
-      model = model_name
+      default = model_name
+      model = session_model(env) || default
       [
         ["version", "#{VERSION} (ruby #{RUBY_VERSION})"],
         ["source", "#{SOURCE_DIR} (#{install_kind})"],
@@ -49,7 +51,8 @@ module Samagotchi
         ["project memories", Tools::MemoryRead.memories_dir("project", env: env)],
         ["sessions", Session.default_state_dir(env: env)],
         ["log", log_path(env)],
-        ["model", model || "(not configured)"],
+        ["model", model ? model_label(model, default, env) : "(not configured)"],
+        ["model key", model ? model_key_for(model, env) : "-"],
         ["host", model ? host_for(model, env) : "-"],
         ["api key", model ? api_key_for(model, env) : "-"],
         ["loop", model ? loop_for(model, env) : "-"],
@@ -125,6 +128,46 @@ module Samagotchi
       nil
     end
 
+    SESSION_MODEL_ENV = "SAMAGOTCHI_SESSION_MODEL"
+    PARENT_SESSION_ENV = "SAMAGOTCHI_PARENT_SESSION"
+
+    # The model of the session this chi self runs in (its execute exports
+    # SAMAGOTCHI_SESSION_MODEL, the resolved ref, live after /model); nil
+    # outside a session's commands.
+    def session_model(env)
+      name = env[SESSION_MODEL_ENV].to_s.strip
+      name.empty? ? nil : name
+    end
+
+    # "splash:x (this session abcd1234; default main:y)", "main:y (this
+    # session abcd1234, the default)", or outside a session "main:y (default)".
+    def model_label(model, default, env)
+      return "#{model} (default)" unless session_model(env)
+
+      id = env[PARENT_SESSION_ENV].to_s
+      session = id.empty? || id == "chi" ? "this session" : "this session #{id[0, 8]}"
+      return "#{model} (#{session}, the default)" if default && same_model?(model, default, env)
+
+      "#{model} (#{session}; default #{default || "not configured"})"
+    end
+
+    def same_model?(one, other, env)
+      return true if one == other
+
+      ConfigFile.model_ref(one, env: env).ref == ConfigFile.model_ref(other, env: env).ref
+    rescue StandardError
+      false
+    end
+
+    # The memory overlay key (ModelOverlay.key_for the bare id, as the
+    # engine keys memory_write current_model_only): which `<name>.<key>.md`
+    # overlays are this model's.
+    def model_key_for(model, env)
+      ModelOverlay.key_for(HostRegistry.new(env: env).bare_name(model)) || "-"
+    rescue StandardError
+      ModelOverlay.key_for(model) || "-"
+    end
+
     def model_name
       ModelProfile.required_model_name
     rescue ArgumentError
@@ -147,6 +190,8 @@ module Samagotchi
       entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
     end
 
+    NO_PROPS = "reported per turn (the server has no /props)"
+
     # chi self's one server call: a single-model llama.cpp answers any name
     # with the model it loaded, and its /props names it (model_alias). One
     # GET with the probe's short timeouts; a remote host isn't asked.
@@ -157,10 +202,11 @@ module Samagotchi
       bare = target.bare_model
       return "-" unless entry
       return "reported per turn (remote host)" if entry.remote?
+      return NO_PROPS if entry.chat?
 
       client = registry.client_for(entry)
       props = client.server_props(model: bare)
-      return "reported per turn (the server has no /props)" if props.nil?
+      return NO_PROPS if props.nil? || props.status == :http_error
       return "unknown (the server didn't answer; is it running?)" if props.status == :network_error
 
       served = ServedModel.from_props(props)

data/lib/samagotchi/send_command.rb

@@ -37,6 +37,8 @@ module Samagotchi
              chi send --wait [--timeout S] [--format json] ID
         Sends a message to each session, as if typed in it: a turn starts,
         or a running one picks it up. A stopped session's worker starts.
+        A session command (/model x, !cmd) runs as the command; --wait
+        then has no reply to wait for (exit 0, status command).
         -m TEXT     the message; stdin, when piped too, goes above it as a
                     quote (context); without -m, stdin is the message
         --image PATH
@@ -64,7 +66,7 @@ module Samagotchi
                     (--wait) one JSON object on stdout, whatever the end:
                     status answered (text), question (question,
                     answer_with), running, or failed, canceled,
-                    no_answer, error, worker_gone, stopped (detail)
+                    no_answer, error, worker_gone, stopped, command (detail)
         Exit with --wait: 0 answered, 1 failed or gone, 2 usage, 3 a
         question waits, 4 still running (--timeout), 130 Ctrl-C.
         Only sessions on this machine. Answers show in the attached TUI
@@ -246,23 +248,27 @@ module Samagotchi
         error_line("chi send: refused: #{refusal}")
         return 1
       end
+      # With images the web's way: idle (the message names it in the
+      # lists), the images copied in, then the message as a turn. So too a
+      # line that may be a session command (/model x): its worker's answer
+      # says whether it ran as one.
+      through_worker = images || command_like?(prompt)
       begin
-        # With images the web's way: idle (the message names it in the
-        # lists), the images copied in, then the message as a turn.
-        start = images ? { prompt: nil, title: prompt } : { prompt: prompt }
+        start = through_worker ? { prompt: nil, title: prompt } : { prompt: prompt }
         session = SessionManager.spawn_session(**start, working_directory: options[:dir],
                                                         model_name: options[:model], state_dir: @state_dir)
       rescue StandardError => e
         error_line("chi send: could not start a session: #{e.message}")
         return 1
       end
-      if images
+      if through_worker
         return 1 unless deliver_new(session, prompt)
       else
         @info.puts("#{session.id}  started")
       end
       @session_id = session.id
       return 0 unless options[:wait]
+      return report_command(session.id) if @sent_command
 
       wait_for_reply(session.id, cursor: nil, baseline: baseline_of(session, question_id: nil),
                                  timeout: options[:timeout])
@@ -297,6 +303,7 @@ module Samagotchi
       cursor = ReplyWait.newest_reply(id, state_dir: @state_dir)
       baseline = baseline_of(session)
       return 1 unless deliver(id, prompt)
+      return report_command(id) if @sent_command
 
       wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout])
     end
@@ -352,10 +359,36 @@ module Samagotchi
         return false
       end
 
-      @info.puts("#{session.id}  started#{with_images}")
+      @sent_command = command_ack?(result[:ack])
+      @info.puts("#{session.id}  started#{with_images}#{"; #{SENT_COMMAND}" if @sent_command}")
       true
     end
 
+    SENT_COMMAND = "sent as a session command"
+
+    # Whether the worker took the message as a session command (a POST
+    # /turn whose line is one answers with its command_id).
+    def command_ack?(ack) = ack.is_a?(Hash) && !ack["command_id"].to_s.empty?
+
+    # Whether +text+ may be a session command, which only its worker knows
+    # (a bundle's too).
+    def command_like?(text) = text.to_s.lstrip.start_with?("/", "!")
+
+    # --wait after a message that ran as a session command: no reply comes
+    # for it. Its output shows where the session is open.
+    # @return [Integer] 0
+    def report_command(id)
+      detail = "#{SENT_COMMAND}: no reply to wait for (its output shows in chi --attach #{id} or the web)"
+      if @json
+        @stdout.puts(JSON.generate({ status: "command", session_id: id, detail: detail }))
+        @stdout.flush
+        @reported = true
+      else
+        @stderr.puts("#{id[0, 8]}  #{detail}")
+      end
+      CLI::Exit::OK
+    end
+
     # @return [Boolean] whether the message was queued
     def deliver(id, prompt)
       short = id[0, 8]
@@ -373,6 +406,12 @@ module Samagotchi
         return false
       end
 
+      @sent_command = command_ack?(result[:ack])
+      if @sent_command
+        @info.puts("#{short}  #{SENT_COMMAND}")
+        return true
+      end
+
       # A busy worker runs a message with images as its own next turn
       # rather than merging it into the running one.
       note = if owner.nil? then " (started its worker)"

data/lib/samagotchi/session.rb

@@ -111,7 +111,9 @@ module Samagotchi
       return nil unless live && pending.is_a?(Hash) && pending[:id]
 
       kind = pending[:kind].to_s
-      { id: pending[:id], kind: %w[approval hook].include?(kind) ? kind : "question" }
+      relayed = pending[:relayed_to]
+      relayed_to = relayed.is_a?(Hash) ? (relayed[:parent_short] || relayed["parent_short"]) : nil
+      { id: pending[:id], kind: %w[approval hook].include?(kind) ? kind : "question", relayed_to: relayed_to }.compact
     end
 
     # The stored project root, else (a file from before the field) the
@@ -464,7 +466,18 @@ module Samagotchi
             entry.is_a?(Hash) ? entry.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } : entry
           end
         end
-        message
+        symbolize_empty_answer(message)
+      end
+
+      # An empty-answer note's marker (TurnNote.empty) and its steps, as
+      # they were saved.
+      def symbolize_empty_answer(message)
+        marker = message[:empty_answer]
+        return message unless marker.is_a?(Hash)
+
+        marker = marker.transform_keys(&:to_sym)
+        marker[:steps] = marker[:steps].map { |step| step.is_a?(Hash) ? step.transform_keys(&:to_sym) : step } if marker[:steps].is_a?(Array)
+        message.merge(empty_answer: marker)
       end
 
       def session_path(session_id, state_dir:)

data/lib/samagotchi/session_manager.rb

@@ -241,7 +241,8 @@ module Samagotchi
     #   a turn running, recap = the saved recap's first sentence, project =
     #   Session#project_root, waiting = the kind of question it waits on
     #   ("question", "approval", "hook"; Session#waiting_question) or nil,
-    #   waiting_id = that question's id or nil
+    #   waiting_id = that question's id or nil, relayed_to = the parent
+    #   whose card it waits in too (the approval relay), its short id, or nil
     def self.session_summaries(live: false, cwd: nil, limit: nil, include_tests: true, exclude: nil, state_dir: nil,
                                project_root: nil, include_archived: false, sort: nil, order: nil)
       sd = state_dir || Session.default_state_dir
@@ -269,7 +270,7 @@ module Samagotchi
     # waiting: the question's kind, waiting_id: its id (what chi answer
     # --question takes); both nil with none.
     def self.waiting_fields(waiting)
-      { waiting: waiting&.dig(:kind), waiting_id: waiting&.dig(:id) }
+      { waiting: waiting&.dig(:kind), waiting_id: waiting&.dig(:id), relayed_to: waiting&.dig(:relayed_to) }
     end
     private_class_method :waiting_fields