samagotchi 0.63.0 → 0.65.0

data/lib/samagotchi/self_report.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "net/http"
-require "uri"
 require_relative "version"
 require_relative "config"
 require_relative "context_window"
@@ -16,8 +13,7 @@ require_relative "thinking"
 require_relative "reasoning_history"
 require_relative "served_model"
 require_relative "host_registry"
-require_relative "llm/http"
-require_relative "llm/api_key"
+require_relative "llm/adapters"
 require_relative "tools/memory"
 require_relative "hooks/loader"
 require_relative "memory_bundle/provenance"
@@ -273,7 +269,9 @@ module Samagotchi
       entry = HostRegistry.new(env: env).resolve(model).entry
       return "-" unless entry
 
-      entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
+      return "native (raw prompt)" unless entry.chat?
+
+      entry.dialect ? "chat (api: #{entry.api}, dialect: #{entry.dialect})" : "chat (api: #{entry.api})"
     end
 
     NO_PROPS = "reported per turn (the server has no /props)"
@@ -281,7 +279,7 @@ module Samagotchi
     # 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. A local
-    # chat host (api: openai) has no /props, so it gets a GET <base>/models
+    # chat host (api: openai or anthropic) has no /props, so it gets its model list
     # with the same timeouts: up/down and the ids it serves.
     def served_model_for(model, env)
       registry = HostRegistry.new(env: env)
@@ -306,36 +304,28 @@ module Samagotchi
       "unknown (#{e.class})"
     end
 
-    # A local chat host's reachability: one GET <base>/models with the
-    # native probe's short timeouts (Client's /props probe), no retry. Up
-    # with the ids it serves, down when it doesn't answer.
+    # A local chat host's reachability: its model list through its own
+    # adapter (LLM::Adapters, not the registry's cached one) with the native
+    # probe's short timeouts (Client's /props probe), no retry. Up with the
+    # ids it serves, down when it doesn't answer.
     def chat_served_model_for(entry, bare, env)
-      uri = URI("#{entry.openai_base_url}/models")
-      request = Net::HTTP::Get.new(uri)
-      http = LLM::HTTP.new(label: entry.name, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
-                           read_timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT,
-                           retry_policy: LLM::HTTP::RetryPolicy.none,
-                           api_key: LLM::ApiKey.for(entry.api_key_env, host: entry.host, env: env))
-      response = http.fetch(uri, request, retries: false, check_status: false, log_fields: { purpose: "models" })
-      return "down (HTTP #{response.code})" unless response.code.to_s == "200"
-
-      ids = chat_model_ids(response.body)
+      adapter = LLM::Adapters.for(entry, open_timeout: Client::CONTEXT_WINDOW_PROBE_OPEN_TIMEOUT,
+                                         timeout: Client::CONTEXT_WINDOW_PROBE_READ_TIMEOUT, retries: false, env: env)
+      ids = adapter.list_models.map(&:id).reject(&:empty?)
       return "up (no models listed)" if ids.empty?
 
       note = ids.any? { |id| id.casecmp?(bare.to_s) } ? "" : " (not #{bare})"
       "up: #{ids.join(", ")}#{note}"
+    rescue LLM::ProviderError => e
+      # A status (an error, or a 3xx such as a proxy's login page) is down;
+      # a 200 whose body isn't a model list (ProtocolError) is up.
+      return "down (HTTP #{e.status})" if e.status
+
+      e.is_a?(LLM::ProtocolError) ? "up (no models listed)" : "down (the server didn't answer; is it running?)"
     rescue StandardError
       "down (the server didn't answer; is it running?)"
     end
 
-    def chat_model_ids(body)
-      parsed = JSON.parse(body.to_s)
-      data = parsed.is_a?(Hash) ? parsed["data"] : parsed
-      Array(data).filter_map { |raw| raw.is_a?(Hash) ? (raw["id"] || raw[:id]).to_s : raw.to_s }.reject(&:empty?)
-    rescue JSON::ParserError
-      []
-    end
-
     # Offline, so no /props probe: where nothing is configured, a native
     # llama.cpp host's chat template decides at runtime.
     def profile_for(model, env)

data/lib/samagotchi/send_command.rb

@@ -38,10 +38,11 @@ module Samagotchi
     CUT_OUTCOMES = %w[now waits off].freeze
 
     USAGE = <<~TEXT
-      Usage: chi send [-m TEXT] [--image PATH]... [--cut] (ID|PREFIX)...
+      Usage: chi send [-m TEXT] [--image PATH]... [--cut | --queue] (ID|PREFIX)...
              chi send --new [--dir DIR] [--model M] [--llm-context LAYERS] [--thinking LEVEL] [-m TEXT] [--image PATH]...
              chi send --new --continues (ID|PREFIX|last:ID) [-m TEXT] [--image PATH]...
              chi send --wait [--timeout S] [--format json] [-m TEXT] [--image PATH]... (--new | ID)
+             chi send --queue --wait [--timeout S] [--format json] [-m TEXT] ID
              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 takes it at its next step. A stopped session's
@@ -92,6 +93,12 @@ module Samagotchi
                     next step and cuts nothing. To an idle session it
                     sends normally. Refused with --wait into a running
                     turn (the steer's turn is the running one)
+        --queue     run the message as a turn of its own after the running
+                    turn ends, instead of merging it at its next step. To
+                    an idle session it runs at once. With --wait it
+                    waits for that turn's own answer, so a running turn
+                    is fine. Not with --cut. Refused for a worker older
+                    than queueing (it would steer; restart it)
         --timeout S (--wait) give up after S seconds, exit 4 (the turn
                     goes on); default no limit
         --format json
@@ -99,8 +106,9 @@ module Samagotchi
                     status answered (text), question (question,
                     answer_with), running, or failed, canceled,
                     limit, no_answer, error, worker_gone, stopped,
-                    command (detail); with --cut also delivery (what
-                    the worker applied) and cut (now, waits, off)
+                    command (detail); with --cut or --queue also
+                    delivery (what the worker applied: next_step, cut,
+                    queue), with --cut also cut (now, waits, off)
         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
@@ -121,6 +129,7 @@ module Samagotchi
       f.value "--image", key: :images, repeat: true
       f.switch "--wait"
       f.switch "--cut"
+      f.switch "--queue"
       f.value "--timeout"
       f.value "--format"
       # Starting a turn in every live session at once is too easy to do
@@ -181,6 +190,7 @@ module Samagotchi
       # With --wait stdout is the answer alone.
       @info = options[:wait] ? @stderr : @stdout
       @cut = options[:cut] == true
+      @queue = options[:queue] == true
       prompt = compose(utf8(read_stdin), utf8(options[:message]))
       # Before the wait-only case, which would drop the images.
       return usage_error("--image needs a message: pass -m TEXT or pipe it in") if prompt.nil? && !options[:images].empty?
@@ -236,6 +246,8 @@ module Samagotchi
       return parsed if parsed.is_a?(Integer)
 
       options = parsed.options.merge(ids: parsed.args)
+      return usage_error("--cut and --queue: choose one") if options[:cut] && options[:queue]
+
       if options[:format]
         return usage_error("--format needs --wait") unless options[:wait]
         return usage_error("--format takes text or json") unless FORMATS.include?(options[:format])
@@ -385,12 +397,15 @@ module Samagotchi
     # are taken before the message goes in, so neither an older reply nor a
     # turn that ends before the first look is mistaken for the answer. A
     # running turn is refused: a message that misses it runs next, and the
-    # running one's reply would come back as the answer.
+    # running one's reply would come back as the answer. Not with --queue:
+    # the message's own turn is waited for (ReplyWait's turn:, its
+    # enqueued_id), whatever runs before it.
     # @return [Integer] the exit status
     def run_wait(prompt, options)
       id = resolve(options[:ids].first) or return 1
       session = Session.load(id, state_dir: @state_dir)
-      if session.status == Session::STATUS_RUNNING && (owner = SessionManager.session_owner(id, state_dir: @state_dir))
+      if session.status == Session::STATUS_RUNNING && (owner = SessionManager.session_owner(id, state_dir: @state_dir)) &&
+         (!@queue || session.waiting_question(live: owner.worker?))
         # The turn waits on a question: the message would only queue
         # behind it, and the answer goes in with chi answer.
         if (waiting = session.waiting_question(live: owner.worker?))
@@ -412,7 +427,11 @@ module Samagotchi
       return 1 unless deliver(id, prompt)
       return report_command(id) if @sent_command
 
-      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout])
+      # The ack's id names the queued message's turn, also when the turn
+      # running at the check ended before it went in (an idle worker's ack
+      # says next_step, and the file still runs as that turn).
+      turn = @queue ? @sent_enqueued_id : nil
+      wait_for_reply(id, cursor: cursor, baseline: baseline, timeout: options[:timeout], turn: turn, queued: !turn.nil?)
     end
 
     # --wait with no message: the session's next reply, sending nothing,
@@ -421,15 +440,18 @@ module Samagotchi
     # was already reported. No message count: a note landing between turns
     # grows the messages without a turn. An idle session with no worker
     # waits for whatever wakes one (the web, chi send) rather than calling
-    # it gone.
+    # it gone. The turn running now, or the one whose continue offer
+    # stands, is the one waited for (ReplyWait.own_turn): its reply, not a
+    # turn's queued behind it; with none known, the next reply.
     # @return [Integer] the exit status
     def run_wait_only(options)
       id = resolve(options[:ids].first) or return 1
       session = Session.load(id, state_dir: @state_dir)
       live = session.status == Session::STATUS_RUNNING || SessionManager.session_owner(id, state_dir: @state_dir)
+      turn = ReplyWait.own_turn(session, session_dir: Session.session_dir(id, state_dir: @state_dir))
       wait_for_reply(id, cursor: ReplyWait.newest_reply(id, state_dir: @state_dir),
                          baseline: baseline_of(session).merge(messages: nil),
-                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil)
+                         timeout: options[:timeout], owner_grace: live ? self.class::WORKER_GONE_AFTER : nil, turn: turn)
     end
 
     # The session as it was before the message went in (ReplyWait's
@@ -535,13 +557,21 @@ module Samagotchi
       owner = SessionManager.session_owner(id, state_dir: @state_dir)
       running = owner && session.status == Session::STATUS_RUNNING
       refs = copy_images(Session.session_dir(id, state_dir: @state_dir))
-      # --cut asks the running turn for a cut; to an idle session it is an
-      # ordinary message (there is nothing to cut).
-      delivery = @cut && running ? Delivery::CUT : nil
+      # --cut asks the running turn for a cut (to an idle session an
+      # ordinary message: nothing to cut). --queue always goes as a queue,
+      # idle or not: the Bridge acks next_step to an idle worker and the
+      # file still carries it, so a turn another client starts first never
+      # merges it, and its turn and reply carry its enqueued_id (the
+      # --wait's turn:); a worker older than queueing is refused.
+      delivery = if @queue then Delivery::QUEUE
+                 elsif @cut && running then Delivery::CUT
+                 end
       result = SessionManager.deliver_turn(id, prompt: prompt, client_id: CLIENT_ID, images: refs, state_dir: @state_dir,
                                                delivery: delivery)
       unless result[:status] == :accepted
-        @info.puts("#{short}  failed: #{result.dig(:ack, "detail") || "could not queue it"}")
+        # A worker older than queueing would steer it: refused, not sent.
+        word = result.dig(:ack, "error") == Delivery::QUEUE_UNAVAILABLE["error"] ? "refused" : "failed"
+        @info.puts("#{short}  #{word}: #{result.dig(:ack, "detail") || "could not queue it"}")
         return false
       end
 
@@ -556,6 +586,7 @@ module Samagotchi
       # (next_step for an idle session) and a cut's outcome.
       @sent_delivery = ack["delivery"] || delivery
       @sent_cut = ack["cut"]
+      @sent_enqueued_id = (ack["enqueued_id"] || ack[:enqueued_id])&.to_s
       @info.puts("#{short}  sent#{with_images}#{delivery_note(ack, delivery: delivery, running: running, owner: owner)}")
       true
     rescue SessionManager::OwnedByTUI
@@ -568,12 +599,14 @@ module Samagotchi
 
     # What the line says became of the message: a plain one goes in at the
     # running turn's next step (nothing cuts by default); a --cut one names
-    # the outcome from the ack (now, waits, off); images keep their own
-    # wording; an idle session's turn simply runs.
+    # the outcome from the ack (now, waits, off); a --queue one runs after
+    # the turn (or now, when the turn ended before it went in); images keep
+    # their own wording; an idle session's turn simply runs.
     # @param ack [Hash] the Bridge's 202 body ({} for the input file)
     # @return [String] "" or " (...)"
     def delivery_note(ack, delivery:, running:, owner:)
       return " (started its worker)" if owner.nil?
+      return queue_note(ack, running: running) if Delivery.queue?(delivery)
       return "" unless running
 
       # A busy worker runs a message with images as its own next turn
@@ -589,12 +622,23 @@ module Samagotchi
       " #{TerminalUI::Formatting.steer_cut_note(outcome.to_sym, ack["cut_after"])}"
     end
 
-    # More keys for --format json, with --cut only (the line is unchanged
-    # otherwise): the delivery the worker applied (next_step to an idle
-    # session) and a cut's outcome (now, waits, off). In P1 --cut --wait is
-    # refused for a running turn, so the json line says next_step.
+    # A --queue, worded from the Bridge's ack: queue when a turn ran as it
+    # went in (one another client started too), next_step when none did
+    # (it runs now). The input file (no Bridge) carries the queue to
+    # whichever turn runs: worded from the session as chi read it.
+    def queue_note(ack, running:)
+      queued = ack.key?("delivery") ? ack["delivery"] == Delivery::QUEUE : running
+      return " (queued: runs after the current turn)" if queued
+
+      running ? " (the running turn had ended: it runs now)" : " (nothing running: it runs now)"
+    end
+
+    # More keys for --format json, with --cut or --queue only (the line is
+    # unchanged otherwise): the delivery the worker applied (next_step to
+    # an idle session) and a cut's outcome (now, waits, off). --cut --wait
+    # is refused for a running turn, so its json line says next_step.
     def report_extra
-      return {} unless @cut
+      return {} unless @cut || @queue
 
       extra = { delivery: @sent_delivery || Delivery::NEXT_STEP }
       extra[:cut] = @sent_cut if @sent_cut

data/lib/samagotchi/session.rb

@@ -722,14 +722,15 @@ module Samagotchi
         symbolize_empty_answer(message)
       end
 
-      # An empty-answer note's marker (TurnNote.empty) and its steps, as
-      # they were saved.
+      # An empty-answer note's marker (TurnNote.empty), its steps and its
+      # refusal, 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)
+        marker[:refusal] = marker[:refusal].transform_keys(&:to_sym) if marker[:refusal].is_a?(Hash)
         message.merge(empty_answer: marker)
       end
 

data/lib/samagotchi/session_commands.rb

@@ -116,7 +116,7 @@ module Samagotchi
       registry.register("/detach", "leave and keep the worker running", local: true, uis: [:attached],
                                                                         match: ->(text) { text.casecmp?("/detach") })
       # /cut TEXT and /queue TEXT while a turn runs: a delivery the UIs parse
-      # themselves (Formatting#steer_choice) before any command check; the
+      # themselves (ComposerRoute.steer_choice) before any command check; the
       # entries exist for Tab completion and /help. The web composer sends
       # /cut too. /queue is a real after-the-turn list only in the local
       # REPL (the attached TUI's worker doesn't skip queued files yet), so

data/lib/samagotchi/session_inbox.rb

@@ -158,11 +158,39 @@ module Samagotchi
       nil
     end
 
-    def self.write_output(session_dir, response)
+    # A turn's reply: output/<timestamp>.txt, or
+    # output/<timestamp>-<enqueued_id>.txt for a turn that ran an input
+    # with an id, so a wait for that input's turn (ReplyWait's turn:) finds
+    # its own reply. The names still sort by time ("-" sorts before ".",
+    # so an id'd name and a bare one of the same timestamp keep order);
+    # every reader globs *.txt.
+    # @param enqueued_id [String, nil] the turn's input id (LastTurn#enqueued_id)
+    def self.write_output(session_dir, response, enqueued_id: nil)
       output_dir = File.join(session_dir, OUTPUT_DIR)
       FileUtils.mkdir_p(output_dir)
       timestamp = Time.now.strftime("%Y%m%d%H%M%S%9N")
-      AtomicFile.write(File.join(output_dir, "#{timestamp}.txt"), response.to_s)
+      AtomicFile.write(File.join(output_dir, "#{output_name(timestamp, enqueued_id)}.txt"), response.to_s)
+    end
+
+    # An id that is safe in a file name (a Bridge's or deliver_turn's
+    # uuid); anything else leaves the name bare.
+    ENQUEUED_ID_NAME = /\A[A-Za-z0-9_-]{1,64}\z/
+
+    def self.output_name(timestamp, enqueued_id)
+      id = enqueued_id.to_s
+      ENQUEUED_ID_NAME.match?(id) ? "#{timestamp}-#{id}" : timestamp
+    end
+    private_class_method :output_name
+
+    # @return [String, nil] the reply filename of the turn that ran the
+    #   input +enqueued_id+, or nil while it has none
+    def self.reply_for(session_dir, enqueued_id)
+      dir = File.join(session_dir, OUTPUT_DIR)
+      id = enqueued_id.to_s
+      return nil if id.empty? || !Dir.exist?(dir)
+
+      suffix = "-#{id}.txt"
+      Dir.children(dir).select { |f| f.end_with?(suffix) }.max
     end
 
     # The output files' text, oldest first; with +since_time+ only files
@@ -218,12 +246,40 @@ module Samagotchi
     end
 
     # Whether a mid-turn drain leaves this unclaimed input file for a turn
-    # of its own instead of merging it at a step boundary. Today that is an
-    # image message (steering merges text only); the drain's file filter
-    # reads this one predicate, so what a boundary refuses changes in one
-    # place.
+    # of its own instead of merging it at a step boundary: a queued message
+    # (`delivery: queue`) or an image message (steering merges text only).
+    # The drain skips such a file without stopping at it, so a later text
+    # line still merges; the drain's file filter reads this one predicate,
+    # so what a boundary leaves changes in one place.
     def self.waits_for_turn_end?(input_file)
-      input_has_images?(input_file)
+      data = JSON.parse(File.read(input_file))
+      data.is_a?(Hash) && (Array(data["images"]).any? || Delivery.queue?(data["delivery"]))
+    rescue JSON::ParserError, SystemCallError
+      false
+    end
+
+    # Whether an input file carrying +enqueued_id+ still waits unclaimed in
+    # input/ (no worker has taken it for a turn or a step yet).
+    def self.input_waiting?(session_dir, enqueued_id) = !waiting_input(session_dir, enqueued_id).nil?
+
+    # How the unclaimed input file carrying +enqueued_id+ waits: :turn_end
+    # (a queue or an image message: it runs as a turn of its own, never
+    # merged, #waits_for_turn_end?), :merges (a running turn's drain may
+    # take it as a steer), or nil when none waits.
+    # @return [Symbol, nil]
+    def self.waiting_input(session_dir, enqueued_id)
+      id = enqueued_id.to_s
+      return nil if id.empty?
+
+      find_new_input_files(session_dir).each do |file|
+        data = JSON.parse(File.read(file))
+        next unless data.is_a?(Hash) && data["enqueued_id"] == id
+
+        return Array(data["images"]).any? || Delivery.queue?(data["delivery"]) ? :turn_end : :merges
+      rescue JSON::ParserError, SystemCallError
+        next
+      end
+      nil
     end
 
     def self.claim_input_file(input_file)

data/lib/samagotchi/session_manager.rb

@@ -205,8 +205,9 @@ module Samagotchi
     # child inherits this process's ENV and reads config.yml itself (as it
     # is when the worker starts); opts[:env] adds to it (merged, not
     # replaced) what it can't read there: this `chi`'s CLI settings
-    # (Config.cli_env), the hosts and the absolute log file. It unsets
-    # SAMAGOTCHI_GUARDRAILS_* and the session markers (SESSION_MARKER_ENV).
+    # (Config.cli_env) and the absolute log file. It unsets
+    # SAMAGOTCHI_GUARDRAILS_*, the session markers (SESSION_MARKER_ENV) and
+    # SAMAGOTCHI_HOSTS_JSON (HOSTS_JSON_ENV).
     # XDG_CONFIG_HOME passes: whoever starts or
     # wakes the worker picks which config.yml it reads (docs/guardrails.md).
     private_class_method def self.spawn_options(session)
@@ -223,14 +224,12 @@ module Samagotchi
         Log.warn(:worker, "cwd_gone", sid: session.id, dir: dir, cwd: Dir.pwd)
       end
       child_env = {}
-      # Propagate hosts config for multi-host routing
-      begin
-        require_relative "config"
-        hosts_json = ConfigFile.hosts_json_for_env
-        child_env["SAMAGOTCHI_HOSTS_JSON"] = hosts_json if hosts_json && !hosts_json.strip.empty?
-      rescue StandardError
-        nil
-      end
+      # The worker reads config.yml's hosts: as it starts, like every other
+      # setting: a host added or changed after this process (a parent
+      # worker, `chi web`) started reaches it. Unset, not just left out: a
+      # worker an older chi started still has one, and its delegates would
+      # inherit its start-time hosts.
+      child_env[HOSTS_JSON_ENV] = nil
       # A worker gets no CLI args: --model, --thinking, --log-level and the
       # other flags this chi was started with.
       child_env.merge!(Config.cli_env)
@@ -694,7 +693,7 @@ module Samagotchi
     # so a resume right after spawns a fresh worker instead of finding the
     # dying one.
     # A turn still running is canceled first (STOP_CANCEL_WAIT), as the
-    # web's Cancel does: its worker saves it. The TERM stops (and saves)
+    # web's Cancel does, with reason STOP_CANCEL_REASON: its worker saves it. The TERM stops (and saves)
     # what still runs (WorkerSignals), with a short grace after the marker.
     # @return [Boolean, nil] with +wait+: whether the owner was gone in time
     # @raise [OwnedByTUI] when the interactive TUI owns the session
@@ -714,7 +713,14 @@ module Samagotchi
       wait_for_owner_release(session_id, timeout: wait, state_dir: sd) if wait
     end
 
+    # ConfigFile.hosts_config's override of config.yml's hosts:, which no
+    # spawned worker inherits (spawn_options).
+    HOSTS_JSON_ENV = "SAMAGOTCHI_HOSTS_JSON"
+
     STOP_CANCEL_WAIT = 3.0
+    # The cancel reason of a turn a session stop cancels (Bridge::CANCEL_REASONS):
+    # not the user's Stop, which only ends the turn ("user").
+    STOP_CANCEL_REASON = "session_stopped"
 
     # Cancel the session's running turn over its Bridge and wait (up to
     # STOP_CANCEL_WAIT) for the worker to save it. Best effort: without a
@@ -723,7 +729,7 @@ module Samagotchi
       return unless Session.load(session_id, state_dir: state_dir).status == Session::STATUS_RUNNING
 
       client = BridgeClient.discover(session_id, session_dir: Session.session_dir(session_id, state_dir: state_dir))
-      return unless client && client.cancel(reason: "user").status == 202
+      return unless client && client.cancel(reason: STOP_CANCEL_REASON).status == 202
 
       BridgeClient.poll(STOP_CANCEL_WAIT) do
         Session.load(session_id, state_dir: state_dir).status != Session::STATUS_RUNNING
@@ -1167,9 +1173,12 @@ module Samagotchi
     #   the session's sidecar, waiting TURN_BRIDGE_WAIT for a new worker's
     # @return [Hash] {status: :accepted, ack: Hash} (the Bridge's reply, or
     #   {status:, enqueued_id:, session_id:} for a file), {status: :refused,
-    #   code:, ack:} when the Bridge refused the images, {status: :timeout,
-    #   ack:} when it took the request but never answered (no file then), or
-    #   {status: :failed} when the input file couldn't be written
+    #   code:, ack:} when the Bridge refused the request (any 4xx with an
+    #   error: bad images, a delivery it doesn't run) or a queue would reach
+    #   a worker that doesn't queue (no file then: it would steer),
+    #   {status: :timeout, ack:} when it took the request but never answered
+    #   (no file then), or {status: :failed} when the input file couldn't be
+    #   written
     # @raise [OwnedByTUI] a chi REPL owns the session
     # @raise [ArgumentError] no such session
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], delivery: nil, state_dir: nil, manager: self,
@@ -1178,20 +1187,28 @@ module Samagotchi
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
       manager.resume_session(session_id, state_dir: state_dir)
       if (client = bridge.call)
+        # A worker from before queueing (no "delivery" feature) ignores the
+        # field or refuses it; either way a file would steer the running turn.
+        return queue_unavailable if Delivery.queue?(delivery) && !worker_queues?(session_dir)
+
         begin
           options = { prompt: prompt, client_id: client_id }
           options[:images] = images unless images.empty?
-          # An old worker ignores the field: it cuts anyway (its own default)
-          # and its file never carries a queue, so a queue would steer there.
+          # An old worker ignores the field: it cuts anyway (its own default).
           options[:delivery] = delivery unless Delivery.next_step?(delivery)
           reply = client.post_turn(**options)
           ack = reply.json
           return { status: :accepted, ack: ack } if reply.status == 202 && ack.is_a?(Hash)
-          if ack.is_a?(Hash) && ack["error"] == "bad_images"
-            return { status: :refused, code: reply.status, ack: ack }
-          end
           # Read after its deadline and dropped: a file would run it after all.
           return turn_timeout if ack.is_a?(Hash) && ack["error"] == "deadline_passed"
+          # Any other 4xx with an error is a refusal (bad images, a delivery
+          # it doesn't run, a client bug): a file would bypass it, and a
+          # refused queue would steer. A 413 (a body over the Bridge's
+          # limit, a big piped chi send) and a 5xx keep the file fallback
+          # below, which carries the delivery (a queue too).
+          if (400..499).cover?(reply.status) && reply.status != 413 && ack.is_a?(Hash) && ack["error"]
+            return { status: :refused, code: reply.status, ack: ack }
+          end
         rescue Errno::ETIMEDOUT
           # The Bridge drops a turn it reads after the request's deadline
           # (BridgeClient#post_turn), so a worker that wakes later won't run
@@ -1222,6 +1239,18 @@ module Samagotchi
       { status: :accepted, ack: { status: "accepted", enqueued_id: enqueued_id, session_id: session_id } }
     end
 
+    # Whether the session's live worker runs delivery: queue (its sidecar
+    # names the feature). No sidecar to read (the client came from a stand-in,
+    # or it went between the wait and here): true, the post finds out.
+    private_class_method def self.worker_queues?(session_dir)
+      sidecar = WorkerSidecar.read(session_dir)
+      sidecar.nil? || sidecar.features.include?(Delivery::QUEUE_FEATURE)
+    end
+
+    private_class_method def self.queue_unavailable
+      { status: :refused, code: 409, ack: Delivery::QUEUE_UNAVAILABLE }
+    end
+
     private_class_method def self.turn_timeout
       { status: :timeout, ack: { "error" => "worker_timeout",
                                  "detail" => "the session's worker did not answer, so the message was not sent" } }

data/lib/samagotchi/session_metrics.rb

@@ -883,7 +883,7 @@ module Samagotchi
       payload = event[:payload]
       payload = {} unless payload.is_a?(Hash)
 
-      @mutex.synchronize { note_first_chunk(payload, event) }
+      @mutex.synchronize { note_first_chunk(event) }
       usage = TokenUsage.from_payload(payload)
       if usage
         @mutex.synchronize { note_server_usage(usage) if @turn }
@@ -915,21 +915,16 @@ module Samagotchi
       turn.gen_had_server = true
     end
 
-    # The first chunk with content, reasoning or a tool call starts the
-    # generation's decode clock (an estimated speed runs from it). Caller
-    # holds the mutex.
-    def note_first_chunk(payload, event)
+    # The first chunk with content, reasoning or a tool call (the loop marks
+    # its event tool_call: true, whatever the wire) starts the generation's
+    # decode clock (an estimated speed runs from it). Caller holds the mutex.
+    def note_first_chunk(event)
       return unless @turn && @turn.gen_open && @turn.gen_first_chunk_at.nil?
-      return unless !event[:content].to_s.empty? || tool_call_delta?(payload)
+      return unless !event[:content].to_s.empty? || event[:tool_call]
 
       @turn.gen_first_chunk_at = monotonic_time
     end
 
-    def tool_call_delta?(payload)
-      choice = payload["choices"].is_a?(Array) ? payload["choices"].first : nil
-      choice.is_a?(Hash) && choice["delta"].is_a?(Hash) && !Array(choice["delta"]["tool_calls"]).empty?
-    end
-
     def event_content_chars(payload, event)
       len = payload_content(payload, event).length
       len.positive? ? len : nil

data/lib/samagotchi/steer_cut.rb

@@ -82,6 +82,10 @@ module Samagotchi
       @waiting.epoch
     end
 
+    # The running generation's phase (GenerationPhase::Snapshot), nil with
+    # none running.
+    def generation_snapshot = @phase.snapshot
+
     # The turn's stream: the generation's phase follows it, and a thinking
     # chunk rechecks a waiting message. +progress+: a chunk's lanes
     # (.lanes), read from it when not given.