samagotchi 0.10.0 → 0.11.0

data/lib/samagotchi/llm/chat_loop.rb

@@ -9,13 +9,16 @@ require_relative "openai_chat"
 require_relative "native_tool_normalizer"
 require_relative "../kernel_loop"
 require_relative "../answer_display"
+require_relative "../context_status"
 require_relative "../context_window"
 require_relative "../context_note"
 require_relative "../tool_runner"
+require_relative "../tool_response"
 require_relative "../tool_declarations"
 require_relative "../vision_context"
 require_relative "../log"
 require_relative "../empty_answer_retry"
+require_relative "../steer"
 require_relative "../turn_note"
 require_relative "../thinking"
 
@@ -188,14 +191,6 @@ module Samagotchi
         nil
       end
 
-      # The status line's context value for +used_tokens+ of +window_tokens+
-      # (KernelLoop#context_display), or nil.
-      def context_display(used_tokens:, window_tokens:)
-        return nil unless @kernel.respond_to?(:context_display)
-
-        @kernel.context_display(used_tokens: used_tokens, window_tokens: window_tokens)
-      end
-
       # A hook failing must not break the turn (as in ToolRunner).
       def fire_hook(name, event)
         hooks = @kernel.hooks if @kernel.respond_to?(:hooks)
@@ -218,9 +213,7 @@ module Samagotchi
           message[:tool_call_id] = entry[:tool_call_id] if entry[:tool_call_id]
           message[:images] = entry[:images] if entry[:images].is_a?(Array) && !entry[:images].empty?
           message[:thinking] = entry[:thinking] if entry[:thinking].is_a?(String) && !entry[:thinking].empty?
-          message[:tool_params] = entry[:tool_params] if entry[:tool_params]
-          message[:tool_labels] = entry[:tool_labels] if entry[:tool_labels]
-          message[:tool_diffs] = entry[:tool_diffs] if entry[:tool_diffs]
+          ToolResponse::SAVED_KEYS.each { |key| message[key] = entry[key] if entry[key] }
           message[TurnNote::RETRY_NUDGE] = true if TurnNote.retry_nudge?(entry)
           message[AnswerDisplay::KEY] = entry[AnswerDisplay::KEY] if entry[AnswerDisplay::KEY]
           ContextNote::KEYS.each { |key| message[key] = entry[key] if entry.key?(key) }
@@ -320,8 +313,8 @@ module Samagotchi
           # usage: the text, and each image's estimate (not its base64).
           @prompt_text = conversation.sum("") { |entry| entry[:content].to_s }
           @image_tokens = ImagePlan.estimated_tokens(conversation)
-          @empty_retries = 0
-          @empty_retry_limit = EmptyAnswerRetry.limit
+          @empty_retry = EmptyAnswerRetry.new
+          @context = ContextStatus.new(conversation: conversation)
         end
 
         EMPTY_ANSWER = "(the model returned an empty answer)"
@@ -346,10 +339,15 @@ module Samagotchi
 
             last_text = @loop.strip_model_thought(response.text)
             if response.tool_calls.empty?
+              # Only whitespace is no answer either (as in the native loop).
+              empty = last_text.strip.empty?
               # Kept before a merge too: the model answers the merged line
               # knowing what it just said.
-              @conversation << with_thinking({ role: "model", content: last_text }, response) unless last_text.empty?
-              retry_empty = last_text.empty? && retry_empty_answer?(iteration, response)
+              @conversation << with_thinking({ role: "model", content: last_text }, response) unless empty
+              retry_empty = empty &&
+                            @empty_retry.retry_empty?(iteration: iteration, cancelled: @cancel_controller&.cancelled?,
+                                                      finish_reason: response.finish_reason,
+                                                      used_tokens: response.usage&.total_tokens, window_tokens: @window&.tokens)
               # An empty answer that will be retried is no answer site: a
               # plugin's steer joins the retry instead of being dropped, and
               # queued input (a user's line, a steer) goes in place of the nudge.
@@ -358,7 +356,7 @@ module Samagotchi
 
               # Shown, not saved: an empty answer (content "" + stop, seen from
               # a remote host) would otherwise end the turn with nothing.
-              last_text = EMPTY_ANSWER if last_text.empty?
+              last_text = EMPTY_ANSWER if empty
               exhausted = false
               break
             end
@@ -376,29 +374,12 @@ module Samagotchi
 
         private
 
-        # A retry is left, and the answer wasn't cut short by a full context
-        # (a length stop while thinking is retried: a thinking loop cut by
-        # the provider's output cap, not a full window).
-        def retry_empty_answer?(iteration, response)
-          return false if @empty_retries >= @empty_retry_limit || @cancel_controller&.cancelled?
-
-          if response.finish_reason.to_s == "length" &&
-             EmptyAnswerRetry.context_full?(response.usage&.total_tokens, @window&.tokens)
-            Log.info(:turn, "empty_answer_not_retried", iteration: iteration, why: "context full")
-            return false
-          end
-          true
-        end
-
         # The hidden nudge before the next generation (EmptyAnswerRetry),
         # which runs at the retry temperature. Returns true.
         def nudge_empty_answer(iteration, response)
-          @empty_retries += 1
-          @retry_generation = true
-          emit(type: :empty_answer_retry, iteration: iteration, attempt: @empty_retries, of: @empty_retry_limit,
-               finish_reason: response.finish_reason, thinking_chars: response.reasoning.to_s.length)
-          @conversation << TurnNote.empty_retry
-          true
+          @empty_retry.nudge!(@conversation, TurnNote.empty_retry,
+                              emit: method(:emit), iteration: iteration, finish_reason: response.finish_reason,
+                              thinking_chars: response.reasoning.to_s.length)
         end
 
         # A generation a plugin cut (stop_generation) is an empty answer made
@@ -410,19 +391,15 @@ module Samagotchi
         def after_cut(iteration, response)
           return canceled(iteration, @cancel_controller.reason) if @cancel_controller.cancelled?
 
-          if @empty_retries < @empty_retry_limit
+          if @empty_retry.left?
             return :retry if inject_pending_input(iteration)
 
-            @empty_retries += 1
-            @retry_generation = true
-            emit(type: :empty_answer_retry, iteration: iteration, attempt: @empty_retries, of: @empty_retry_limit,
-                 finish_reason: response.finish_reason, thinking_chars: response.reasoning.to_s.length,
-                 stopped_by: response.cut[:by])
-            @conversation << TurnNote.cut_retry(response.cut[:by], response.cut[:reason])
+            @empty_retry.nudge!(@conversation, TurnNote.cut_retry(response.cut[:by], response.cut[:reason]),
+                                emit: method(:emit), iteration: iteration, finish_reason: response.finish_reason,
+                                thinking_chars: response.reasoning.to_s.length, stopped_by: response.cut[:by])
             return :retry
           end
-          index = @conversation.rindex { |entry| TurnNote.retry_nudge?(entry) }
-          @conversation.delete_at(index) if index
+          @empty_retry.drop_nudge!(@conversation)
           @cancel_controller.cancel!(:hook, response.cut)
           canceled(iteration, :hook)
         end
@@ -440,8 +417,8 @@ module Samagotchi
         # text] when it was cancelled.
         def generate(iteration)
           window = @window = @loop.context_window(@model_name)
-          retry_generation = @retry_generation
-          @retry_generation = false
+          observe_context(iteration, window)
+          retry_generation = @empty_retry.take_sampling!
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
                context_window_source: window&.source)
           @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
@@ -517,13 +494,49 @@ module Samagotchi
             !error.context_overflow? && !@loop.thinking_fields(@model_name).empty?
         end
 
-        # The status line's value from the server's counts for this request
-        # (prompt + answer); without them the last value stays.
+        # Before a request, as the native loop: estimate how full the window
+        # is (the server's last count plus what the turn appended since),
+        # emit :context_status on a bucket change, and put the model's own
+        # line on the tail on a rise that asks it for a change. The estimate
+        # counts the conversation's text and tool calls, not the tool
+        # schemas (the server's count does).
+        def observe_context(iteration, window)
+          return unless window
+
+          @request_image_tokens = ImagePlan.estimated_tokens(@conversation)
+          event = @context.observe(prompt_chars, iteration_index: iteration - 1, window: window,
+                                                 image_tokens: @request_image_tokens)
+          emit(type: :context_status, iteration: iteration, **event) if event
+          if (line = @context.take_guidance)
+            @conversation << line
+          end
+          @request_chars = prompt_chars
+        end
+
+        # The conversation's text as the request carries it: contents (a
+        # parts list's text parts) and the tool calls' names and arguments.
+        def prompt_chars
+          @conversation.sum do |entry|
+            content = entry[:content]
+            chars = if content.is_a?(Array)
+                      content.sum { |part| part.is_a?(Hash) ? (part[:text] || part["text"]).to_s.length : 0 }
+                    else
+                      content.to_s.length
+                    end
+            chars + Array(entry[:tool_calls]).sum { |call| call[:name].to_s.length + call[:arguments].to_json.length }
+          end
+        end
+
+        # The server's counts for this request (prompt + answer): the status
+        # line's value, and where the next estimate starts. Without them the
+        # estimate stays.
         def record_context_status(usage, window)
-          return unless usage.source == :server && window
+          return unless usage.source == :server
 
-          display = @loop.context_display(used_tokens: usage.total_tokens, window_tokens: window.tokens)
-          @context_status = display if display
+          counts = @context.capture({ "usage" => { "prompt_tokens" => usage.prompt_tokens,
+                                                   "completion_tokens" => usage.completion_tokens } })
+          @context.generation_done(counts, prompt_chars: @request_chars.to_i, image_tokens: @request_image_tokens.to_i,
+                                           window: window)
         end
 
         # The model's answer at debug level, as the native loop dumps its
@@ -539,44 +552,22 @@ module Samagotchi
                                         served_model: response.model, tool_calls: calls.empty? ? nil : calls.join(","))
         end
 
+        # Each call's result goes on the conversation as it finishes, paired
+        # with its call (ToolResponse.single: the capped output).
         def dispatch(tool_calls, iteration, cap)
-          emit(type: :tool_dispatch_started, iteration: iteration, call_count: tool_calls.length)
-          tool_calls.each_with_index do |tool_call, index|
-            call = NativeToolNormalizer.normalize(tool_call)
-            run = @loop.tool_runner.run(call, iteration: iteration, call_index: index + 1, call_count: tool_calls.length,
-                                              on_stream_event: @on_stream_event, max_tool_output_chars: cap)
-            @tool_activity << run[:activity] if run[:activity]
-            # The chat loop feeds the model the capped output (native feeds
-            # the full one; D-P2-6).
-            entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call.id }
-            entry[:images] = run[:images] if run[:images]&.any?
-            # A plugin tool's params line, for the web's reload; never sent.
-            entry[:tool_params] = run[:shown_params] if run[:shown_params]
-            entry[:tool_labels] = run[:shown_label] if run[:shown_label]
-            # What an edit/write changed, for the web's reload; never sent.
-            entry[:tool_diffs] = run[:diff] if run[:diff]
-            @conversation << entry
+          calls = tool_calls.map { |tool_call| NativeToolNormalizer.normalize(tool_call) }
+          runs = ToolResponse.run_batch(@loop.tool_runner, calls, iteration: iteration, emit: method(:emit),
+                                                                  on_stream_event: @on_stream_event, cap: cap) do |run, index|
+            @conversation << ToolResponse.single(run, tool_call_id: tool_calls[index].id)
           end
-          emit(type: :tool_dispatch_completed, iteration: iteration, call_count: tool_calls.length)
+          @tool_activity.concat(ToolResponse.activities(runs))
         end
 
-        # Queued steering joins the conversation as one user message, a
-        # plugin's steers each as its own after it (Steer). Returns true when
-        # there was any. After a cancel it stays queued, so it runs as the
-        # next turn instead of dying with this one. +answer+ is the answer the
-        # merge follows, for the UIs; given, the drain is told it is the
-        # after-answer site (plugin steers are dropped there).
+        # Queued input at an iteration boundary (Steer.inject!). Returns true
+        # when there was any.
         def inject_pending_input(iteration, answer: nil)
-          return false unless @pending_input
-          return false if @cancel_controller&.cancelled?
-
-          merge = Steer.merge(Steer.drain(@pending_input, at_answer: !answer.nil?))
-          return false if merge.empty?
-
-          @conversation.concat(merge.messages)
-          emit(type: :pending_input_merged, iteration: iteration, **merge.event_fields,
-               answer: answer.to_s.empty? ? nil : answer)
-          true
+          Steer.inject!(@conversation, @pending_input, iteration: iteration, emit: method(:emit),
+                                                       cancel_controller: @cancel_controller, answer: answer)
         end
 
         # The text streamed before the cancel stays, marked [interrupted],
@@ -589,13 +580,13 @@ module Samagotchi
           conversation.last[:interrupted] = true unless visible.empty?
           ModelResult.new(text: "", provider: :chat, conversation: conversation, canceled: true,
                           cancellation_reason: reason, tool_activity: @tool_activity, usage: usage,
-                          context_status: @context_status)
+                          context_status: @context.display)
         end
 
         def result(text, exhausted:)
           ModelResult.new(text: text, provider: :chat, conversation: @loop.plain(@conversation), exhausted: exhausted,
                           tool_activity: @tool_activity, usage: usage, empty_answer: text == EMPTY_ANSWER,
-                          context_status: @context_status)
+                          context_status: @context.display)
         end
 
         def usage

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

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

@@ -114,7 +114,7 @@ module Samagotchi
     # 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,7 +125,9 @@ 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?
 
@@ -146,7 +148,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 +181,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 +194,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,16 +80,16 @@ 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?
 
@@ -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

data/lib/samagotchi/session.rb

@@ -40,6 +40,10 @@ module Samagotchi
     # from it (--mute): the worker rebuilds the same prompt on a respawn.
     # Names as given; the engine normalizes them.
     attr_accessor :preloaded_memory_names, :muted_memory_names
+    # The name model_name was typed as when that differs from the resolved
+    # ref stored in model_name (an alias: `small` for `gemma-small`), else
+    # nil. The models: lookup takes it (HostRegistry#lookup_names).
+    attr_accessor :model_typed
     # The project the session was started in (ProjectScope.root_for its
     # folder), stored because worktrees are deleted after a merge and a
     # deleted folder no longer leads to its repository. nil outside a repo,
@@ -70,11 +74,12 @@ module Samagotchi
                    first_preview: "", test_run: false, pending_question: nil,
                    used_memory_names: [], project_root: nil,
                    preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, scratch: false,
-                   last_turn: nil)
+                   last_turn: nil, model_typed: nil)
       @id = id
       @metadata_version = metadata_version
       @mode = mode
       @model_name = model_name
+      @model_typed = model_typed
       @working_directory = working_directory
       @messages = messages
       @created_at = created_at
@@ -113,7 +118,7 @@ module Samagotchi
     #   seed); [] by default
     def self.new_session(mode:, model_name:, working_directory:, test_run: nil,
                          preloaded_memory_names: [], muted_memory_names: [], parent_id: nil, messages: [],
-                         scratch: false)
+                         scratch: false, model_typed: nil)
       now = Time.now.iso8601(3)
       resolved_test = if test_run.nil?
                         test_session_env?
@@ -124,6 +129,7 @@ module Samagotchi
         id: SecureRandom.uuid,
         mode: mode.to_s,
         model_name: model_name.to_s,
+        model_typed: model_typed,
         working_directory: working_directory.to_s,
         messages: Array(messages).map(&:dup),
         created_at: now,
@@ -173,6 +179,7 @@ module Samagotchi
       "id" => REQUIRED,
       "mode" => REQUIRED,
       "model_name" => REQUIRED,
+      "model_typed" => nil,
       "working_directory" => REQUIRED,
       "messages" => [],
       "created_at" => REQUIRED,