samagotchi 0.11.0 → 0.12.0

data/lib/samagotchi/llm/model_result.rb

@@ -3,29 +3,20 @@
 module Samagotchi
   module LLM
     # Normalized result returned by every ModelBackend downstream of the agentic
-    # loop. The loop lives INSIDE the backend (Option A), so raw provider tool
-    # calls are never surfaced — `tool_calls` is always `nil` downstream.
-    #
-    # It deliberately mirrors the read surface Engine#run_turn and the renderers
-    # (TerminalUI / Bridge) currently consume off KernelLoop::Result, so wiring
-    # the seam in does not require changes to those consumers:
-    #   .conversation, .canceled?, .cancellation_reason, .output, .exhausted?
-    # plus the native loop's .tool_activity, .context_status and
-    # .pending_tool_calls, which the interactive renderer needs.
+    # loop (the loop lives inside the backend). What Engine#run_turn and the
+    # renderers (TerminalUI / Bridge) read: .output (= .text, and .to_s, which
+    # is how the :turn_completed `result:` reaches JSON), .conversation,
+    # .canceled?, .cancellation_reason, .exhausted?, .resumable?,
+    # .empty_answer?, plus the native loop's .tool_activity, .context_status
+    # and .pending_tool_calls, which the interactive renderer needs.
     class ModelResult
-      attr_reader :text, :tool_calls, :provider, :usage, :metadata,
-                  :conversation, :canceled, :cancellation_reason, :exhausted,
+      attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
                   :tool_activity, :context_status, :pending_tool_calls
 
-      def initialize(text:, tool_calls: nil, provider: nil, usage: nil, metadata: nil,
-                     conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
+      def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
                      tool_activity: [], context_status: nil, pending_tool_calls: false, empty_answer: false)
         @empty_answer = empty_answer
         @text = text
-        @tool_calls = tool_calls
-        @provider = provider
-        @usage = usage
-        @metadata = metadata
         @conversation = conversation
         @canceled = canceled
         @cancellation_reason = cancellation_reason
@@ -44,10 +35,13 @@ module Samagotchi
         !!canceled
       end
 
-      # The turn ended with nothing visible: the text shown is a placeholder,
-      # the conversation holds no reply.
+      # The turn ended with nothing visible: no text, or the chat loop's
+      # placeholder (empty_answer:). A cancelled turn or one that can be
+      # continued is not an empty answer.
       def empty_answer?
-        !!@empty_answer
+        return false if canceled? || resumable?
+
+        !!@empty_answer || text.to_s.strip.empty?
       end
 
       def exhausted?

data/lib/samagotchi/llm/native_backend.rb

@@ -2,12 +2,11 @@
 
 require_relative "backend"
 require_relative "model_result"
-require_relative "usage"
 
 module Samagotchi
   module LLM
     # The raw-prompt loop as a backend: KernelLoop#run (llama.cpp /completion,
-    # Gemma/Qwen prompt formats) with its result wrapped in a ModelResult, so
+    # Gemma/Qwen prompt formats), which returns a ModelResult itself, so
     # Engine and the TUI call every backend the same way.
     class NativeBackend < ModelBackend
       def initialize(kernel:)
@@ -18,32 +17,15 @@ module Samagotchi
 
       def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
-        usage = UsageCollector.new
-        kernel_result = @kernel.run(
+        @kernel.run(
           messages,
           max_iterations: max_iterations,
-          on_stream_event: lambda { |event|
-            usage.observe(event)
-            on_stream_event&.call(event)
-          },
+          on_stream_event: ->(event) { on_stream_event&.call(event) },
           cancel_controller: cancel_controller,
           model_name: model_name,
           max_tool_output_chars: max_tool_output_chars,
           pending_input: pending_input
         )
-        ModelResult.new(
-          text: kernel_result.output.to_s,
-          tool_calls: nil,
-          provider: :native,
-          usage: usage.usage(prompt_text: Array(messages).sum("") { |message| message[:content].to_s }),
-          conversation: kernel_result.conversation,
-          canceled: kernel_result.canceled?,
-          cancellation_reason: kernel_result.cancellation_reason,
-          exhausted: kernel_result.exhausted,
-          tool_activity: kernel_result.tool_activity,
-          context_status: kernel_result.context_status,
-          pending_tool_calls: kernel_result.pending_tool_calls
-        )
       end
     end
   end

data/lib/samagotchi/llm/openai_chat.rb

@@ -56,7 +56,7 @@ module Samagotchi
       # @param entry [HostRegistry::HostEntry]
       def self.for(entry, **options)
         new(base_url: entry.openai_base_url, host_name: entry.name, api_key_env: entry.api_key_env,
-            remote: entry.respond_to?(:remote?) && entry.remote?, **options)
+            remote: entry.remote?, **options)
       end
 
       # Tool arguments as a Hash; "" is {}, invalid JSON stays a String.

data/lib/samagotchi/llm/turn_settings.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../thinking"
+
+module Samagotchi
+  module LLM
+    # A turn's settings on the kernel, read by both loops (KernelLoop,
+    # ChatLoop) and ToolRunner: the turn's VisionContext (nil sends no
+    # images, placeholders instead), its request parameters
+    # (SamplingSettings.for; empty sends none), its thinking level
+    # (Thinking.resolve) and the bare model id the turn runs on (every
+    # debug dump is tagged with it). The Engine sets them once per turn,
+    # in Engine#generate, after the model's host is synced.
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name) do
+      # No vision, no sampling, the default thinking, no model name.
+      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil)
+    end
+  end
+end

data/lib/samagotchi/llm/usage.rb

@@ -4,8 +4,8 @@ require_relative "../token_usage"
 
 module Samagotchi
   module LLM
-    # A turn's token counts, never nil: what the server reported (:server),
-    # else a chars/4 estimate (:estimate), else zeros (:none).
+    # A response's token counts, never nil: what the server reported
+    # (:server), else zeros (:none).
     Usage = Data.define(:prompt_tokens, :completion_tokens, :source) do
       # @return [Usage, nil] nil when the payload carries no counts
       def self.from_payload(payload)
@@ -16,64 +16,9 @@ module Samagotchi
             source: :server)
       end
 
-      # +extra_prompt_tokens+: what the prompt holds besides text (images).
-      def self.estimate(prompt_text:, completion_text:, extra_prompt_tokens: 0)
-        new(prompt_tokens: TokenUsage.estimate(prompt_text.to_s) + extra_prompt_tokens.to_i,
-            completion_tokens: TokenUsage.estimate(completion_text.to_s),
-            source: :estimate)
-      end
-
       def self.none = new(prompt_tokens: 0, completion_tokens: 0, source: :none)
 
       def total_tokens = prompt_tokens + completion_tokens
     end
-
-    # Builds a turn's Usage from its stream events, the way SessionMetrics
-    # counts them: server counts are cumulative per request, so each
-    # generation keeps its highest; the prompt grows across a turn's
-    # generations, so the last generation's prompt counts, and completions
-    # add up. Without server counts, the streamed text is estimated.
-    class UsageCollector
-      def initialize
-        @generations = []
-      end
-
-      def observe(event)
-        case event[:type]
-        when :generation_started
-          @generations << { prompt: 0, completion: 0, server: false, text: +"" }
-        when :generation_chunk
-          @generations << { prompt: 0, completion: 0, server: false, text: +"" } if @generations.empty?
-          record(@generations.last, event)
-        end
-      end
-
-      # @param prompt_text [String, nil] what an estimate counts as the prompt
-      # @param extra_prompt_tokens [Integer] estimated non-text prompt tokens
-      def usage(prompt_text: nil, extra_prompt_tokens: 0)
-        server = @generations.select { |generation| generation[:server] }
-        unless server.empty?
-          return Usage.new(prompt_tokens: server.last[:prompt], completion_tokens: server.sum { |g| g[:completion] },
-                           source: :server)
-        end
-
-        text = @generations.sum("") { |generation| generation[:text] }
-        return Usage.none if text.empty?
-
-        Usage.estimate(prompt_text: prompt_text, completion_text: text, extra_prompt_tokens: extra_prompt_tokens)
-      end
-
-      private
-
-      def record(generation, event)
-        counts = Usage.from_payload(event[:payload])
-        if counts
-          generation[:server] = true
-          generation[:prompt] = [generation[:prompt], counts.prompt_tokens].max
-          generation[:completion] = [generation[:completion], counts.completion_tokens].max
-        end
-        generation[:text] << event[:content].to_s
-      end
-    end
   end
 end

data/lib/samagotchi/memory_bundle/installer.rb

@@ -365,7 +365,7 @@ module Samagotchi
             version: manifest.version,
             source_path: @source,
             hooks: hooks_for_provenance,
-            trust_level: manifest.respond_to?(:trust_level) ? manifest.trust_level : nil,
+            trust_level: manifest.trust_level,
             source_commit: source_commit,
             hooks_files: hooks_files_for_provenance,
             guardrails_files: guardrail_files_for_provenance,

data/lib/samagotchi/model_catalog.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "host_registry"
+
+module Samagotchi
+  # The hosts' model listings (HostRegistry#list_all_models) as rows a user
+  # picks from: GET /api/models and `chi models`. Every name question goes
+  # to ModelRef / HostRegistry#resolve; nothing here parses a ref.
+  module ModelCatalog
+    # host: the host that listed the id; ref: the name `--model` takes for
+    # it (see .spell).
+    Row = Data.define(:host, :id, :ref)
+    # rows: the default host's first, then the others by name; warnings:
+    # "host: error" per host that failed.
+    Listing = Data.define(:rows, :warnings)
+
+    module_function
+
+    # @param results [Hash] list_all_models' answer
+    # @param registry [#default_entry]
+    # @return [Listing]
+    def listing(results, registry:)
+      default_host = registry.default_entry&.name
+      rows = []
+      warnings = []
+      results.keys.sort_by { |name| [name == default_host ? 0 : 1, name] }.each do |host|
+        data = results[host]
+        if data[:error]
+          warnings << "#{host}: #{data[:error]}"
+          next
+        end
+        Array(data[:models]).each do |info|
+          id = info.id.to_s
+          next if id.strip.empty? || id.end_with?(":batch")
+
+          rows << Row.new(host: host, id: id, ref: spell(host, id, default_host))
+        end
+      end
+      Listing.new(rows: rows, warnings: warnings)
+    end
+
+    # A listed id as a ref that routes back to its host: bare on the
+    # default host (a bare id goes there first), "host:id" elsewhere and for
+    # a default-host id with a ':' (bare, "qwen3:8b" would name a host qwen3).
+    # '/' doesn't name a host, so "openai/gpt-4o" stays bare.
+    def spell(host, id, default_host)
+      host == default_host && !id.include?(":") ? id : "#{host}:#{id}"
+    end
+
+    # `chi models --format json`'s object. default_host: where bare names
+    # go first (its rows are the "default host" group). default: the default's listed
+    # row name when it resolves to one, else its resolved ref; default_typed:
+    # the alias it was typed as. A row whose name resolves elsewhere (an
+    # alias named like the id shadows it) carries shadowed_by.
+    # @param default_name [String, nil] default.model as configured
+    # @return [Hash]
+    def payload(results, registry:, default_name:)
+      listing = listing(results, registry: registry)
+      models = listing.rows.map do |row|
+        hash = { name: row.ref, host: row.host, id: row.id }
+        shadow = shadowed_by(row, registry)
+        shadow ? hash.merge(shadowed_by: shadow) : hash
+      end
+      default, typed = default_for(default_name, listing.rows, registry)
+      { default: default, default_typed: typed, default_host: registry.default_entry&.name, models: models,
+        aliases: aliases(registry), warnings: listing.warnings }
+    end
+
+    # The alias (or the ref) that takes +row+'s name elsewhere, or nil.
+    def shadowed_by(row, registry)
+      target = registry.resolve(row.ref)
+      return nil if target.entry.name == row.host && target.bare_model == row.id
+
+      registry.model_ref(row.ref).alias_name || "#{target.entry.name}:#{target.bare_model}"
+    end
+
+    def default_for(name, rows, registry)
+      return [nil, nil] if name.to_s.strip.empty?
+
+      ref = registry.model_ref(name)
+      target = registry.resolve(name)
+      row = rows.find { |r| r.host == target.entry.name && r.id.casecmp?(target.bare_model) }
+      [row ? row.ref : ref.ref, ref.alias_name ? name.to_s.strip : nil]
+    end
+
+    # config.yml's aliases, each under the host its target goes to: the
+    # default host's first, then by host and name.
+    def aliases(registry)
+      default_host = registry.default_entry&.name
+      names = begin
+        ConfigFile.model_aliases
+      rescue StandardError
+        {}
+      end
+      rows = names.keys.map do |name|
+        { name: name, ref: registry.model_ref(name).ref, host: registry.resolve(name).entry.name }
+      end
+      rows.sort_by { |row| [row[:host] == default_host ? 0 : 1, row[:host], row[:name]] }
+    end
+  end
+end

data/lib/samagotchi/model_profile.rb

@@ -324,7 +324,7 @@ module Samagotchi
       return false if client.nil? || !client.respond_to?(:server_props)
       return false if entry&.chat?
 
-      !client.respond_to?(:transport) || client.transport.name == :llama_cpp
+      client.transport.name == :llama_cpp
     end
     private_class_method :probe?
 

data/lib/samagotchi/models_command.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "host_registry"
+require_relative "model_catalog"
+require_relative "model_profile"
+require_relative "cli/command"
+require_relative "cli/flags"
+
+module Samagotchi
+  # `chi models`: the names `--model` (and `chi send --new --model`) takes,
+  # listed anew from every host in parallel, within a bounded wait; the
+  # desktop helper's model picker reads --format json. No cache: each run
+  # lists every host (the registry's TTLs live in one process only).
+  class ModelsCommand
+    include CLI::Command
+
+    DEFAULT_TIMEOUT = 4.0
+    FORMATS = %w[text json].freeze
+
+    USAGE = <<~TEXT
+      Usage: chi models [--format text|json] [--timeout S] [TEXT]
+        Lists the models every configured host offers, as the names
+        --model takes: the default first, a default-host id bare, another
+        host's as host:id, then the aliases as "name -> ref". A host that
+        fails or doesn't answer in time is noted on stderr.
+        TEXT          only the names containing it (any case)
+        --format json the default, the models (host, id, name), the aliases
+                      and the warnings as one JSON object
+        --timeout S   wait at most S seconds for the hosts; default 4
+        Exit 0 when any host listed its models, 1 when none did (the
+        default is still printed), 2 on a usage error.
+    TEXT
+
+    FLAGS = CLI::Flags.new(help: CLI::Command::HELP_WORDS) do |f|
+      f.value "--format"
+      f.value "--timeout"
+    end
+
+    # @param registry [HostRegistry, nil] specs inject one
+    # @param default_name [String, nil, :config] default.model; :config reads it
+    def initialize(argv, stdout: $stdout, stderr: $stderr, registry: nil, default_name: :config)
+      @argv = argv.dup
+      @stdout = stdout
+      @stderr = stderr
+      @registry = registry
+      @default_name = default_name
+    end
+
+    # @return [Integer] 0 any host listed, 1 none did, 2 usage
+    def run
+      parsed = parse_flags(FLAGS, @argv, format: "text", timeout: DEFAULT_TIMEOUT.to_s)
+      return parsed if parsed.is_a?(Integer)
+
+      options = parsed.options
+      return usage_error("--format takes text or json") unless FORMATS.include?(options[:format])
+
+      timeout = Float(options[:timeout], exception: false)
+      return usage_error("--timeout takes a number of seconds above 0") unless timeout&.positive?
+
+      payload, listed = catalog(timeout)
+      payload = filtered(payload, parsed.args.join(" ").strip)
+      options[:format] == "json" ? print_json(payload) : print_text(payload)
+      listed ? 0 : 1
+    end
+
+    private
+
+    def command_name = "chi models"
+
+    # @return [Array(Hash, Boolean)] the payload and whether any host listed
+    def catalog(timeout)
+      registry = @registry || HostRegistry.new
+      results = registry.list_all_models(force: true, wait: timeout)
+      listed = results.values.any? { |data| data[:error].nil? }
+      [ModelCatalog.payload(results, registry: registry, default_name: default_name), listed]
+    rescue StandardError => e
+      [{ default: default_name, default_typed: nil, default_host: nil, models: [], aliases: [], warnings: [e.message] }, false]
+    end
+
+    def default_name
+      return @default_name unless @default_name == :config
+
+      ModelProfile.required_model_name
+    rescue ArgumentError
+      nil
+    end
+
+    def filtered(payload, text)
+      return payload if text.empty?
+
+      needle = text.downcase
+      payload.merge(models: payload[:models].select { |m| m[:name].downcase.include?(needle) },
+                    aliases: payload[:aliases].select { |a| "#{a[:name]} #{a[:ref]}".downcase.include?(needle) },
+                    filter: text)
+    end
+
+    def print_json(payload)
+      @stdout.puts(JSON.generate(payload.except(:filter)))
+    end
+
+    def print_text(payload)
+      default = payload[:default]
+      names = payload[:models].reject { |m| m[:shadowed_by] }.map { |m| m[:name] }
+      shown_default = default && (payload[:filter].nil? || default.downcase.include?(payload[:filter].downcase))
+      @stdout.puts(default) if shown_default
+      (names - [default]).each { |name| @stdout.puts(name) }
+      payload[:aliases].each { |a| @stdout.puts("#{a[:name]} -> #{a[:ref]}") }
+      payload[:warnings].each { |w| @stderr.puts("chi models: #{w}") }
+    end
+  end
+end

data/lib/samagotchi/reminder_queue.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Samagotchi
+  # The session's due reminders, on their way into a turn.
+  #
+  # The ReminderStore is the truth (a reminder is due once its interval
+  # passed). This adds the names the idle tick found due and handed to the
+  # UI's callback (#note_pending): the worker and the REPL run a reminder
+  # turn while they are pending. A turn injects whatever is due then
+  # (#inject!), which marks it fired and clears the pending names.
+  class ReminderQueue
+    # @param store [ReminderStore, nil]
+    def initialize(store:)
+      @store = store
+      @lock = Monitor.new
+      @pending = []
+    end
+
+    # @return [Array<Hash>] the reminders due now ({name:, description:, interval_minutes:})
+    def due
+      @store&.due_reminders || []
+    end
+
+    # @return [Boolean] whether any reminder is due now (the store's view,
+    #   which #inject! would inject), regardless of the pending names
+    def due?
+      !due.empty?
+    end
+
+    # @return [Array<String>] the names queued for a reminder turn
+    def pending_names
+      @lock.synchronize { @pending.dup }
+    end
+
+    # Queue names for a reminder turn (the idle tick's callback).
+    def note_pending(names)
+      @lock.synchronize { @pending = Array(names).dup }
+    end
+
+    # @return [Boolean] whether names are queued (the idle tick waits meanwhile)
+    def pending?
+      @lock.synchronize { !@pending.empty? }
+    end
+
+    def clear_pending!
+      @lock.synchronize { @pending = [] }
+    end
+
+    # Inject the due reminders into a turn's messages as one tail system
+    # message (after the history, before the user's message), mark them
+    # all fired under one store lock, and clear the pending names.
+    #
+    # A tail message, not the head system prompt: changing the head would
+    # make the model server re-evaluate the whole conversation's prefix
+    # (its KV cache) every interval; a tail costs only the new suffix.
+    # @param messages [Array<Hash>] the turn's messages (appended to)
+    # @return [Array<Hash>] the reminders injected (maybe none)
+    def inject!(messages)
+      reminders = due
+      return [] if reminders.empty?
+
+      lines = reminders.map { |r| "  #{r[:name]}: #{r[:description]} (interval: #{r[:interval_minutes]}m)" }.join("\n")
+      messages << { role: "system", content: "[SYSTEM: REMINDERS DUE]\n#{lines}\n[END REMINDERS]" }
+      @store.mark_fired_batch(reminders.map { |r| r[:name] })
+      # Without this a turn's injection leaves a stale name, and the next
+      # reminder turn would run with nothing due.
+      clear_pending!
+      reminders
+    end
+  end
+end

data/lib/samagotchi/reminder_store.rb

@@ -15,8 +15,8 @@ module Samagotchi
   #
   # Reminder lifecycle:
   #   1. Agent calls register_reminder → store adds entry
-  #   2. IdleReminders detects due → sets @due_reminder_name on Engine
-  #   3. Engine#run_turn reads @due_reminder_name, injects [SYSTEM:] message
+  #   2. IdleReminders detects due while idle → the UI queues a reminder turn
+  #   3. Engine#run_turn injects what is due as a [SYSTEM:] message (ReminderQueue#inject!)
   #   4. Agent acts on reminder → calls cancel_reminder → store removes entry
   class ReminderStore
     # @return [Hash{String => Hash}] id => {id:, name:, description:, interval_minutes:, next_fire_at:}
@@ -90,7 +90,7 @@ module Samagotchi
 
     # Get all due reminders whose interval has elapsed.
     # Returns an Array of {name:, description:, interval_minutes:} hashes.
-    # Called by Engine#collect_due_reminders (synchronously, at run_turn start).
+    # Read by ReminderQueue (a turn's injection, the idle tick).
     # Thread-safe. Returns a frozen copy so the caller can't mutate internal state.
     # @return [Array<Hash>] array of due reminder hashes (may be empty)
     def due_reminders

data/lib/samagotchi/self_report.rb

@@ -111,6 +111,13 @@ module Samagotchi
       nil
     end
 
+    # `chi self --model`, the desktop helper's hint: the default as the ref
+    # it resolves to (an alias applied, ModelRef), as `chi models` names it.
+    def model_ref_name(env: ENV)
+      name = model_name
+      name && ConfigFile.model_ref(name, env: env).ref
+    end
+
     # Routed without model discovery, so an unqualified name may land on
     # another host at runtime after /models.
     def loop_for(model, env)
@@ -132,7 +139,7 @@ module Samagotchi
       return "reported per turn (remote host)" if entry.remote?
 
       client = registry.client_for(entry)
-      props = client.server_props(model: bare) if client.respond_to?(:server_props)
+      props = client.server_props(model: bare)
       return "reported per turn (the server has no /props)" if props.nil?
       return "unknown (the server didn't answer; is it running?)" if props.status == :network_error
 

data/lib/samagotchi/send_command.rb

@@ -95,7 +95,7 @@ module Samagotchi
 
       profile = ModelProfile.resolve(names: names, entry: entry, client: target.client, bare_model: target.bare_model).profile
       answer = VisionSupport.for(target, profile: profile, names: names)
-      props = target.client.respond_to?(:server_props) ? target.client.server_props(model: target.bare_model) : nil
+      props = target.client.server_props(model: target.bare_model)
       return UNKNOWN_VISION if answer.no? && !props&.answered? && !configured_no?(answer)
 
       answer

data/lib/samagotchi/session_commands.rb

@@ -404,7 +404,7 @@ module Samagotchi
 
     def persist_session_model
       session = @engine.session
-      return unless session.respond_to?(:model_name=)
+      return unless session
 
       @engine.store_model!(session)
       begin
@@ -416,7 +416,7 @@ module Samagotchi
 
     # "; served: <name>" when the server serves another model than asked.
     def served_note
-      served, asked = @engine.respond_to?(:served_model) ? @engine.served_model : nil
+      served, asked = @engine.served_model
       ServedModel.differs?(asked, served) ? "; served: #{served}" : ""
     rescue StandardError
       ""
@@ -424,7 +424,7 @@ module Samagotchi
 
     # "; sampling: temperature=0.6 (hosts.work)" when the model has any.
     def sampling_note
-      summary = @engine.respond_to?(:sampling_summary) ? @engine.sampling_summary : nil
+      summary = @engine.sampling_summary
       summary ? "; sampling: #{summary}" : ""
     rescue StandardError
       ""
@@ -432,7 +432,7 @@ module Samagotchi
 
     # "; thinking: off (models: qwen)" when the model has a level set.
     def thinking_note
-      summary = @engine.respond_to?(:thinking_summary) ? @engine.thinking_summary : nil
+      summary = @engine.thinking_summary
       summary ? "; thinking: #{summary}" : ""
     rescue StandardError
       ""
@@ -447,7 +447,7 @@ module Samagotchi
     end
 
     def chat_model?
-      @engine.respond_to?(:chat_model?) && @engine.chat_model?
+      @engine.chat_model?
     rescue StandardError
       false
     end

data/lib/samagotchi/session_manager.rb

@@ -765,7 +765,7 @@ module Samagotchi
     def self.deliver_turn(session_id, prompt:, client_id: nil, images: [], state_dir: nil, manager: self, bridge: nil)
       session_dir = Session.session_dir(session_id, state_dir: state_dir || Session.default_state_dir)
       bridge ||= -> { BridgeClient.wait_for(session_id, session_dir: session_dir, timeout: TURN_BRIDGE_WAIT) }
-      manager.resume_session(session_id, state_dir: state_dir) if manager.respond_to?(:resume_session)
+      manager.resume_session(session_id, state_dir: state_dir)
       if (client = bridge.call)
         begin
           options = { prompt: prompt, client_id: client_id }
@@ -802,9 +802,7 @@ module Samagotchi
       end
       # A worker that idle-exited since the resume never reads it either:
       # wake a new one. (The exiting worker also looks for input it left.)
-      if owner.nil? && manager.respond_to?(:session_owner) && manager.respond_to?(:resume_session)
-        manager.resume_session(session_id, state_dir: state_dir)
-      end
+      manager.resume_session(session_id, state_dir: state_dir) if owner.nil?
       { status: :accepted, ack: { status: "accepted", enqueued_id: enqueued_id, session_id: session_id } }
     end
 
@@ -814,8 +812,6 @@ module Samagotchi
     end
 
     private_class_method def self.delivery_owner(manager, session_id, state_dir)
-      return nil unless manager.respond_to?(:session_owner)
-
       manager.session_owner(session_id, state_dir: state_dir)
     rescue StandardError
       nil