samagotchi 0.10.1 → 0.12.0

data/lib/samagotchi/host_registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "config"
+require_relative "model_ref"
 require_relative "client"
 require_relative "llm/openai_chat"
 
@@ -14,8 +15,9 @@ module Samagotchi
   #   /models), not on startup. Each host's list is cached (60s, 10 minutes
   #   for a remote host) with skip-on-error; lists are LLM::ModelInfo.
   # - Routing: client_for_model resolves a (possibly qualified) model string
-  #   to the appropriate Client instance. A remote host is chosen only by
-  #   exact model id, host:model or an alias, never by a substring.
+  #   to the appropriate Client instance: host:model, an alias, or an exact
+  #   id in a cached list (default host first, then hosts: order); never by
+  #   a substring.
   class HostRegistry
     CACHE_TTL_SECONDS = 60
     REMOTE_CACHE_TTL_SECONDS = 600
@@ -45,8 +47,7 @@ module Samagotchi
       def openai_base_url = url || "#{root_url}/v1"
 
       # A provider on the network rather than a local server: it needs a key
-      # or speaks https. Its model list is cached longer and it is never
-      # picked by a substring of a model name.
+      # or speaks https. Its model list is cached longer.
       def remote? = !api_key_env.to_s.empty? || scheme == "https"
 
       def models_ttl = remote? ? REMOTE_CACHE_TTL_SECONDS : CACHE_TTL_SECONDS
@@ -106,7 +107,7 @@ module Samagotchi
       @mutex = Mutex.new
       @cache = nil
       @cache_at = nil
-      @model_index = nil # downcased model_id => host_name
+      @model_index = nil # downcased model_id => [host_name] in hosts: order
     end
 
     def entries
@@ -142,79 +143,26 @@ module Samagotchi
     # @param target [ModelTarget, nil] the resolved model's target (resolved when not given)
     # @return [Array<String>]
     def lookup_names(typed, resolved: nil, target: nil)
-      aliased = ConfigFile.resolve_model_alias(typed, env: @env)
-      target ||= resolve(resolved || aliased)
-      [typed, aliased, resolved, parse_qualified_model(typed).last, target.bare_model]
+      target ||= resolve(resolved || typed)
+      [typed, model_ref(typed).ref, resolved, parse_qualified_model(typed).last, target.bare_model]
         .map { |name| name.to_s.strip }.reject(&:empty?).uniq
     end
 
-    # Resolve model string (already alias-resolved, may be qualified) to a HostEntry.
-    # If qualified explicitly, return that host. If unqualified, try cached model index,
-    # else fallback to default host.
+    # The host a model name, alias or host:model ref goes to and the model
+    # id it is sent as (ModelRef: one alias pass). A ref that names a host
+    # goes there. A bare id goes to the default host when its cached list
+    # has it, else to the first host in hosts: order whose list has it,
+    # else to the default host (before /models nothing is listed: no
+    # discovery here, the latency budget). Never by a substring.
     def host_for_model(raw_model)
-      host_ref, bare = parse_qualified_model(raw_model)
-      # If qualified, try to resolve alias on the bare part (small-box:small -> small-box:gemma-small)
-      if host_ref && bare
-        begin
-          aliases = ConfigFile.model_aliases
-          resolved = aliases.fetch(bare.downcase, bare)
-          bare = resolved if resolved != bare
-        rescue StandardError
-          nil
-        end
-        # parse_qualified_model names a host only when it is one of ours
-        return [find_entry(host_ref), bare]
-      end
-      # Unqualified: also try alias resolution for discovery (small -> gemma-small or small -> small-box:gemma-small)
-      begin
-        aliases = ConfigFile.model_aliases
-        resolved = aliases.fetch(bare.to_s.strip.downcase, bare)
-        if resolved != bare
-          # If alias points to a qualified ref, re-parse it
-          q_host, q_bare = parse_qualified_model(resolved)
-          if q_host
-            entry = find_entry(q_host)
-            return [entry, q_bare] if entry
-          end
-          bare = resolved
-        end
-      rescue StandardError
-        nil
-      end
-      bare_down = bare.to_s.strip.downcase
-      # Try cached index (populated after list_all_models)
-      idx = @mutex.synchronize { @model_index }
-      if idx && idx.key?(bare_down)
-        host_name = idx[bare_down]
-        entry = find_entry(host_name)
-        return [entry, bare] if entry
-      end
-      # Fallback: try substring match in cached aggregated results if available
-      # (lightweight: scan cached model lists). Remote hosts match exactly only.
-      cached = @mutex.synchronize { @cache }
-      if cached
-        cached.each do |hname, data|
-          next unless data[:models]
-          data[:models].each do |m|
-            if m.id.downcase == bare_down
-              entry = find_entry(hname)
-              return [entry, bare] if entry
-            end
-          end
-        end
-        cached.each do |hname, data|
-          next unless data[:models]
-          next if find_entry(hname)&.remote?
-
-          data[:models].each do |m|
-            if m.id.downcase.include?(bare_down)
-              entry = find_entry(hname)
-              return [entry, bare] if entry
-            end
-          end
-        end
-      end
-      [default_entry, bare]
+      ref = model_ref(raw_model)
+      # ModelRef names a host only when it is one of ours
+      return [find_entry(ref.host_name), ref.id] if ref.host_name
+
+      listed = @mutex.synchronize { @model_index }&.fetch(ref.id.to_s.strip.downcase, nil) || []
+      default = default_entry
+      name = listed.include?(default.name) ? default.name : listed.first
+      [(name && find_entry(name)) || default, ref.id]
     end
 
     # The chat adapter for a host (one per host, so its cached model list
@@ -247,20 +195,30 @@ module Samagotchi
       [client_for(host_entry), bare, host_entry]
     end
 
-    # The single host/model resolution: alias and host routing (host_for_model)
-    # plus the name sent to the server (bare_name).
+    # The single host/model resolution: the alias applied, the host and
+    # the name sent to the server (host_for_model).
     # @param raw_model [String] a model name, alias or host:model ref
     # @return [ModelTarget]
     def resolve(raw_model)
-      entry, = host_for_model(raw_model)
-      ModelTarget.new(model: raw_model, entry: entry, bare_model: bare_name(raw_model), client: client_for(entry))
+      entry, bare = host_for_model(raw_model)
+      ModelTarget.new(model: raw_model, entry: entry, bare_model: bare, client: client_for(entry))
     end
 
-    # The model name without a known host prefix ("box:gemma" → "gemma").
-    # Aliases are not applied here.
+    # The model id sent for +full_ref+: its alias applied, a known host
+    # prefix stripped ("box:gemma" → "gemma").
     def bare_name(full_ref)
-      _, bare = parse_qualified_model(full_ref)
-      bare.to_s.strip.empty? ? full_ref.to_s.strip : bare
+      model_ref(full_ref).id
+    end
+
+    # +raw+ parsed against these hosts and config.yml's aliases.
+    # @return [ModelRef]
+    def model_ref(raw)
+      aliases = begin
+        ConfigFile.model_aliases(env: @env)
+      rescue StandardError
+        {}
+      end
+      ModelRef.parse(raw, hosts: @entries, aliases: aliases)
     end
 
     def client_for(entry)
@@ -271,7 +229,14 @@ module Samagotchi
     # Returns { host_name => { host:, port:, transport:, models: [LLM::ModelInfo], error: nil|String } }
     # Also populates the model index. Unless forced, a host's list is reused
     # for its TTL (60s; 10 minutes for a remote host).
-    def list_all_models(force: true)
+    #
+    # With +wait+ (seconds), answers by one shared deadline: a host still
+    # listing then gets the error "no answer in S s" and its thread is left
+    # running (only for a short-lived process: `chi models`). Such a partial
+    # listing is not stored as the cache or the model index, so a later
+    # resolve doesn't miss the slow host's ids; finished hosts' lists are
+    # kept for their TTL as usual.
+    def list_all_models(force: true, wait: nil)
       results = {}
       results_mutex = Mutex.new
       threads = @entries.map do |name, entry|
@@ -289,19 +254,38 @@ module Samagotchi
           results_mutex.synchronize { results[name] = data }
         end
       end
-      threads.each { |thread| thread.join if thread.is_a?(Thread) }
+      if wait
+        deadline = @clock.call + wait
+        threads.each { |thread| thread.join([deadline - @clock.call, 0].max) if thread.is_a?(Thread) }
+        partial = false
+        # a new hash: the threads keep writing into +results+ (their closure's)
+        snapshot = results_mutex.synchronize do
+          @entries.each_with_object({}) do |(name, entry), acc|
+            acc[name] = results.fetch(name) do
+              partial = true
+              { host: entry.host, port: entry.port, transport: entry.transport, models: [],
+                error: "no answer in #{wait == wait.to_i ? wait.to_i : wait} s" }
+            end
+          end
+        end
+        return snapshot if partial
+      else
+        threads.each { |thread| thread.join if thread.is_a?(Thread) }
+      end
+
+      # Model index: model_id downcased -> the hosts listing it, in hosts:
+      # order (not the order the threads answered in).
+      index = Hash.new { |h, k| h[k] = [] }
+      @entries.each_key do |hname|
+        data = results[hname]
+        next if data.nil? || data[:error]
 
-      # Build model index: model_id downcased -> host_name (first host wins)
-      index = {}
-      results.each do |hname, data|
-        next if data[:error]
         Array(data[:models]).each do |m|
-          mid = m.id.to_s
-          next if mid.strip.empty?
-          down = mid.downcase
-          index[down] = hname unless index.key?(down)
+          down = m.id.to_s.strip.downcase
+          index[down] << hname unless down.empty? || index[down].include?(hname)
         end
       end
+      index.default_proc = nil
 
       @mutex.synchronize do
         @cache = results

data/lib/samagotchi/idle_reminders.rb

@@ -1,64 +1,42 @@
 # frozen_string_literal: true
 
-require "monitor"
-
-require_relative "reminder_store"
+require_relative "reminder_queue"
 
 module Samagotchi
   # Idle job for periodic reminders — polled by the shared IdleScheduler
   # (one background thread for the whole idle layer).
   #
   # Two delivery paths cooperate:
-  #   1. Pull-based: Engine#collect_due_reminders
-  #      reads ReminderStore#due_reminders at turn start → injects
-  #      [SYSTEM: REMINDERS DUE] → marks all as fired atomically.
+  #   1. Every turn injects what is due (ReminderQueue#inject!, from
+  #      Engine#run_turn) as [SYSTEM: REMINDERS DUE] and marks it fired.
   #   2. Synthetic turns: when this job's tick finds due reminders while
-  #      idle, it latches @due_reminder_name and fires @auto_turn_callback
-  #      (the TUI/SessionManager queue a synthetic turn from the latch).
+  #      idle, it fires @auto_turn_callback, which queues their names
+  #      (Engine#note_due_reminders) for the worker's or the REPL's
+  #      reminder turn. While names are queued the tick waits; whoever
+  #      clears them (a turn's injection, the reminder turn's consumer)
+  #      re-arms it. The queue is the only "already due" state.
   class IdleReminders
     DEFAULT_MIN_INACTIVITY_SECONDS = 60.0 # Minimum idle time before checking for reminders
 
     attr_reader :inactivity
 
     def initialize(engine:, inactivity: DEFAULT_MIN_INACTIVITY_SECONDS,
-                   reminder_store: nil,
+                   queue: nil,
                    clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) },
                    callback: nil)
       raise ArgumentError, "IdleReminders requires an engine" unless engine
 
       @engine = engine
       @inactivity = inactivity
-      @reminder_store = reminder_store || engine.instance_variable_get(:@reminder_store)
+      @queue = queue
       @clock = clock
       @auto_turn_callback = callback
-
-      @mutex = Monitor.new
-      @due_reminder_name = nil
-    end
-
-    # Get all due reminders (from ReminderStore). Called by Engine#collect_due_reminders.
-    # Thread-safe. Returns all due reminders, not just one.
-    # @return [Array<Hash>] [{name:, description:, interval_minutes:}, ...]
-    def due_reminders
-      @reminder_store&.due_reminders || []
-    end
-    # Get the names of all due reminders. Called by the background thread to
-    # determine which reminders need a synthetic turn.
-    # @return [Array<String>] reminder names that are due
-    def due_reminder_names
-      due_reminders.map { |r| r[:name] }
-    end
-
-    # Clear the pending due reminder (after it has been delivered).
-    # Called by Engine after injecting the reminder into the system prompt.
-    def clear_due
-      @mutex.synchronize { @due_reminder_name = nil }
     end
 
     # One detector step, called by the shared IdleScheduler. Public so specs
     # can drive it deterministically.
     def tick
-      return if @due_reminder_name # already due, waiting for engine to deliver
+      return if @queue&.pending? # already queued, waiting for a turn to deliver it
       return unless should_check?
 
       check_due_reminders
@@ -78,14 +56,13 @@ module Samagotchi
     end
 
     def check_due_reminders
-      return unless @reminder_store
-      due_names = @reminder_store.due_reminders.map { |r| r[:name] }
+      return unless @queue
+      due_names = @queue.due.map { |r| r[:name] }
       return if due_names.empty?
       # Signal the engine to create a synthetic turn via callback.
       # The callback is responsible for triggering a turn (e.g. SessionManager
       # writes a file, TerminalUI queues input). The engine's run_turn or
       # REPL injection point then picks up and delivers the reminders.
-      @mutex.synchronize { @due_reminder_name = due_names.first }
       if @auto_turn_callback
         @auto_turn_callback.call(due_names)
       end