samagotchi 0.10.1 → 0.12.0

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

@@ -129,15 +129,23 @@ module Samagotchi
 
     # Raises UnknownHost when +model_name+ (or the alias it names) is
     # qualified with a host that isn't configured, instead of sending the
-    # whole ref to the default host as a model id. Where a model comes in
-    # (an Engine starting or switching, a spawned session) calls it.
+    # whole ref to the default host as a model id, and when an alias after
+    # a host prefix names another host ("openrouter:tiny" with tiny:
+    # box:…). Where a model comes in (an Engine starting or switching, a
+    # spawned session) calls it.
     # @param hosts [Hash, nil] the hosts a prefix may name (a HostRegistry's
     #   entries); config.yml's by default
     # @return [String] +model_name+
     def self.check_host!(model_name, env: ENV, hosts: nil)
       require_relative "config"
       hosts ||= Samagotchi::ConfigFile.hosts_config(env: env)
-      ref = Samagotchi::ConfigFile.resolve_model_alias(model_name, env: env, hosts: hosts)
+      parsed = Samagotchi::ConfigFile.model_ref(model_name, env: env, hosts: hosts)
+      if (other = parsed.host_conflict)
+        raise UnknownHost, "alias '#{parsed.alias_name}' names host '#{other}', not '#{parsed.host_name}'; " \
+                           "use #{parsed.alias_name} or #{other}:#{parsed.alias_name}"
+      end
+      ref = parsed.ref
+      warn_host_slash(ref, hosts) unless parsed.host_name
       host = Samagotchi::ConfigFile.unknown_host_prefix(ref, hosts: hosts)
       return model_name unless host
 
@@ -147,6 +155,17 @@ module Samagotchi
       raise UnknownHost, "unknown host '#{host}' in model '#{ref}'#{hint}; the configured hosts are #{names.join(', ')}"
     end
 
+    # "box/x" named host box until '/' stopped naming a host: a saved
+    # session or a hand-written ref says so once, then goes to the default host.
+    def self.warn_host_slash(ref, hosts)
+      prefix, rest = ref.to_s.split("/", 2)
+      return if rest.to_s.empty? || !hosts.keys.map { |k| k.to_s.downcase }.include?(prefix.downcase)
+
+      Samagotchi::ConfigFile.warn_once("Warning: model '#{ref}' starts with the host '#{prefix}' and '/': only ':' names a host now, " \
+                                       "so it goes to the default host as written; use #{prefix}:#{rest} (/model #{prefix}:#{rest})")
+    end
+    private_class_method :warn_host_slash
+
     # One line for the user: where to set the model.
     def self.missing_model_message
       path = begin
@@ -305,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/model_ref.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # A model ref as written (--model, /model, default.model, an alias's
+  # target): an optional host prefix and a model id or alias. Pure: it is
+  # given the configured hosts and aliases and asks nothing else. Routing a
+  # name without a host to one (the model index after /models) is
+  # HostRegistry's.
+  #
+  # Aliases apply once (an alias naming another alias sends that name as
+  # written), also after a host prefix ("box:small"). An alias whose target
+  # names another host than the prefix is a conflict (#host_conflict),
+  # refused where a model comes in (ModelProfile.check_host!).
+  #
+  # typed: the ref as given, stripped.
+  # host_name: the host the ref names (downcased), its own or its alias's;
+  #   nil when it names none.
+  # id: the model id the host is asked for.
+  # alias_name: the alias applied (as typed), else nil.
+  # alias_host: the host the alias's target names, else nil.
+  ModelRef = Data.define(:typed, :host_name, :id, :alias_name, :alias_host) do
+    # Splits "host:model" when the prefix is a configured host and something
+    # follows it. Only ':' names a host: "openai/gpt-4o" is an id (OpenRouter's).
+    # @param hosts [Hash] configured hosts by name (any value)
+    # @return [Array(String, String)] [host_name or nil, the rest]
+    def self.split(raw, hosts:)
+      value = raw.to_s.strip
+      return [nil, value] if value.empty?
+
+      prefix, rest = value.split(":", 2)
+      return [nil, value] if rest.nil? || rest.strip.empty?
+      return [nil, value] unless (hosts || {}).keys.map { |k| k.to_s.downcase }.include?(prefix.strip.downcase)
+
+      [prefix.strip.downcase, rest.strip]
+    end
+
+    # @param aliases [Hash{String => String}] alias (downcased) => target
+    # @return [ModelRef]
+    def self.parse(raw, hosts:, aliases:)
+      value = raw.to_s.strip
+      host, rest = split(value, hosts: hosts)
+      name = host ? rest : value
+      target = aliases[name.downcase]
+      return new(typed: value, host_name: host, id: name, alias_name: nil, alias_host: nil) unless target
+
+      alias_host, alias_id = split(target, hosts: hosts)
+      new(typed: value, host_name: host || alias_host, id: alias_host ? alias_id : target, alias_name: name,
+          alias_host: alias_host)
+    end
+
+    # The resolved ref a session stores: "host:id", or the id when no host
+    # is named (routed when it runs).
+    def ref = host_name ? "#{host_name}:#{id}" : id
+
+    # The host the alias names when the ref's own prefix names another, else nil.
+    def host_conflict
+      alias_host if alias_host && alias_host != host_name
+    end
+  end
+end

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/prompt_history.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+require_relative "atomic_file"
+require_relative "config"
+require_relative "paths"
+require_relative "session_commands"
+
+module Samagotchi
+  # The prompts typed at a chi prompt, kept for ↑ across launches: one
+  # global file (config history.file, else
+  # $XDG_STATE_HOME/samagotchi/history.json), a JSON array oldest first. An
+  # older file with one prompt per line still reads. The TUI and the web
+  # server both append, so appends hold <file>.lock and replace the file
+  # atomically (mode 0600: the web serves it to LAN token holders).
+  module PromptHistory
+    FILE = "history.json"
+    STATE_DIR = "samagotchi"
+    LIMIT = 100
+
+    module_function
+
+    # @return [String] the history file
+    def path
+      explicit = Config.get("history.file").to_s.strip
+      return explicit unless explicit.empty?
+
+      File.join(Paths.state_home, STATE_DIR, FILE)
+    end
+
+    # @return [Array<String>] the saved entries, oldest first; [] when the
+    #   file is missing or unreadable
+    def entries
+      file = path
+      return [] unless File.file?(file)
+
+      raw = File.read(file)
+      normalize(JSON.parse(raw))
+    rescue JSON::ParserError
+      normalize(raw.to_s.lines.map(&:chomp))
+    rescue StandardError
+      []
+    end
+
+    # Add +line+ as the newest entry, keeping the last LIMIT. The re-read
+    # happens under the lock, so two writers never drop each other's line.
+    # The rename replaces a symlinked history.file with a regular file.
+    # @param line [String]
+    def append(line)
+      file = path
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open("#{file}.lock", File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        list = entries << line
+        AtomicFile.write(file, JSON.pretty_generate(list.last(LIMIT)) + "\n", perm: 0o600)
+      end
+    end
+
+    # What changes when anyone writes the file: its mtime and size.
+    # @return [Array, nil] nil without a file
+    def signature
+      stat = File.stat(path)
+      [stat.mtime, stat.size]
+    rescue SystemCallError
+      nil
+    end
+
+    # The entries +now+ has after the ones +seen+ earlier: the longest end
+    # of +seen+ that +now+ starts with lines the two up (appends trim the
+    # front); when nothing lines up, all of +now+.
+    # @return [Array<String>]
+    def new_tail(seen, now)
+      (0..seen.size).each do |drop|
+        kept = seen.size - drop
+        return now.drop(kept) if kept <= now.size && now.first(kept) == seen.last(kept)
+      end
+      now
+    end
+
+    # A `!command` worth recalling; `!rollback` isn't one.
+    def shell_line?(line)
+      line.to_s.start_with?(SessionCommands::SHELL_BANG_PREFIX) && line.to_s.strip != SessionCommands::ROLLBACK_COMMAND
+    end
+
+    def normalize(list)
+      Array(list).map { |entry| entry.to_s.gsub(/\r\n?/, "\n").strip }.reject(&:empty?)
+    end
+  end
+end

data/lib/samagotchi/recap_setup.rb

@@ -46,6 +46,11 @@ module Samagotchi
       if base_url.nil? && host_ref.nil? && model.nil?
         target = -> { session_target.call }
       else
+        # The model as any model ref (ModelRef): its alias applied once, and
+        # its host (own or the alias's) picks the recap host when host_ref
+        # doesn't.
+        parsed = model && host_registry.model_ref(model)
+        host_ref ||= parsed.host_name if parsed && base_url.nil?
         # If host_ref given, derive base_url (the host's OpenAI base) and its
         # API key variable from the host_registry entry
         api_key_env = nil
@@ -54,13 +59,20 @@ module Samagotchi
           if entry
             base_url = entry.openai_base_url
             api_key_env = entry.api_key_env
-            # If model is host-qualified, extract bare model for recap client
-            _, bare = host_registry.parse_qualified_model(model) if model
-            model = bare if bare && !bare.empty?
+            named = parsed&.host_conflict || parsed&.host_name
+            if named && named != entry.name
+              Log.warn(:recap, "model_host_mismatch",
+                       echo: "Warning: recap model '#{model}' names host '#{named}', not recap.host_ref '#{host_ref}'; recap disabled.",
+                       model: model, host_ref: host_ref)
+              return nil
+            end
+            model = parsed.id if parsed
           else
             Log.warn(:recap, "host_ref_unknown", echo: "Warning: recap host_ref '#{host_ref}' not found in hosts:; recap disabled.", host_ref: host_ref)
             return nil
           end
+        elsif parsed && !parsed.host_name
+          model = parsed.id
         end
 
         if base_url.to_s.strip.empty? || model.to_s.strip.empty?

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,10 +111,17 @@ 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)
-      entry, = HostRegistry.new(env: env).host_for_model(model)
+      entry = HostRegistry.new(env: env).resolve(model).entry
       return "-" unless entry
 
       entry.chat? ? "chat (api: openai)" : "native (raw prompt)"
@@ -125,12 +132,14 @@ module Samagotchi
     # GET with the probe's short timeouts; a remote host isn't asked.
     def served_model_for(model, env)
       registry = HostRegistry.new(env: env)
-      entry, bare = registry.host_for_model(model)
+      target = registry.resolve(model)
+      entry = target.entry
+      bare = target.bare_model
       return "-" unless entry
       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
 
@@ -146,7 +155,9 @@ module Samagotchi
     # llama.cpp host's chat template decides at runtime.
     def profile_for(model, env)
       registry = HostRegistry.new(env: env)
-      entry, bare = registry.host_for_model(model)
+      target = registry.resolve(model)
+      entry = target.entry
+      bare = target.bare_model
       return "name-based (chat API: only strips thoughts)" if entry&.chat?
 
       names = registry.lookup_names(model)
@@ -177,7 +188,9 @@ module Samagotchi
     end
 
     def host_for(model, env)
-      entry, bare = HostRegistry.new(env: env).host_for_model(model)
+      target = HostRegistry.new(env: env).resolve(model)
+      entry = target.entry
+      bare = target.bare_model
       return "(no hosts configured)" unless entry
 
       suffix = bare && bare != model ? " as #{bare}" : ""
@@ -188,8 +201,7 @@ module Samagotchi
     # The variable the host's API key comes from and whether it is set; the
     # key itself is never shown.
     def api_key_for(model, env)
-      entry, = HostRegistry.new(env: env).host_for_model(model)
-      name = entry&.api_key_env
+      name = HostRegistry.new(env: env).resolve(model).entry&.api_key_env
       return "-" unless name
 
       "#{name} (#{env[name].to_s.empty? ? "unset" : "set"})"

data/lib/samagotchi/send_command.rb

@@ -80,22 +80,22 @@ module Samagotchi
     # takes images, decided as its worker decides before a turn with images
     # (Engine#turn_vision: VisionSupport, with models.<name>.vision under
     # the name as given (maybe an alias), the alias's target, the part
-    # after a host prefix and the bare name, as after /model). A native
+    # after a host prefix and the bare name). A native
     # host whose /props doesn't answer is unknown here, not a no: the
     # worker asks again when the turn runs.
+    # @param typed [String, nil] the name the model was typed as (a session's model_typed)
     # @return [VisionSupport::Answer] value nil when unknown
-    def self.vision_answer(model_name, registry: nil)
+    def self.vision_answer(model_name, registry: nil, typed: nil)
       registry ||= HostRegistry.new
       name = ModelProfile.required_model_name(model_name)
-      aliased = ConfigFile.resolve_model_alias(name)
-      target = registry.resolve(aliased)
-      names = registry.lookup_names(name, target: target)
+      target = registry.resolve(name)
+      names = registry.lookup_names(typed.to_s.strip.empty? ? name : typed, resolved: name, target: target)
       entry = target.entry
       return VisionSupport.for(target, adapter: registry.adapter_for(entry), names: names) if entry.chat?
 
       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
@@ -385,7 +385,7 @@ module Samagotchi
     def deliver(id, prompt)
       short = id[0, 8]
       session = Session.load(id, state_dir: @state_dir)
-      if !@images.empty? && (refusal = vision_refusal(session.model_name))
+      if !@images.empty? && (refusal = vision_refusal(session.model_name, typed: session.model_typed))
         @info.puts("#{short}  refused: #{refusal}")
         return false
       end
@@ -415,9 +415,9 @@ module Samagotchi
 
     # What to say when +model_name+ is known not to take images, or nil
     # (it does, or it is unknown: sent as before). Asked once per model.
-    def vision_refusal(model_name)
+    def vision_refusal(model_name, typed: nil)
       @vision ||= {}
-      answer = @vision[model_name.to_s] ||= self.class.vision_answer(model_name)
+      answer = @vision[[model_name.to_s, typed.to_s]] ||= self.class.vision_answer(model_name, typed: typed)
       return nil unless answer.no?
 
       name = model_name.to_s.strip