samagotchi 0.156.0 → 0.158.0

data/lib/samagotchi/hooks.rb

@@ -2,12 +2,11 @@
 
 require_relative "hooks/registry"
 require_relative "hooks/loader"
-require_relative "hooks/bundle_loader"
 require_relative "hooks/stream_watch"
 
 module Samagotchi
-  # Thin wrapper that exposes the Hooks::Registry, Hooks::Loader and
-  # Hooks::BundleLoader (bundle-owned hook plugins).
+  # Thin wrapper that exposes the Hooks::Registry and Hooks::Loader
+  # (config.yml's hooks; a bundle's hook through its plugin, Plugin::Api#on).
   #
   # The Engine holds an instance of Hooks::Registry and provides:
   # - #register_hook(name, &block) — register a turn-scoped hook

data/lib/samagotchi/host_address.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require_relative "config"
+
+module Samagotchi
+  # What a host's address says about it, without asking it: whether it is
+  # remote (a provider on the network rather than a local server), and the
+  # configured first-token limit. A leaf: HostRegistry::HostEntry and
+  # BootstrapCommand read it, it reads only Config.
+  module HostAddress
+    # Loopback, private (RFC 1918, IPv6 unique local) and link-local nets.
+    LOCAL_NETS = %w[127.0.0.0/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10
+                    ::1/128 fc00::/7 fe80::/10].map { |net| IPAddr.new(net) }.freeze
+
+    # Name suffixes that stay on a home or office network: mDNS, the
+    # special-use and customary private names, router defaults (fritz.box)
+    # and Tailscale's MagicDNS. Compared on whole labels.
+    LOCAL_NAME_SUFFIXES = %w[localhost local lan home home.arpa internal intranet localdomain private corp test
+                             box ts.net].freeze
+
+    # Whether an address is remote: https, an http IP address outside the
+    # local nets (LOCAL_NETS), or an http name with a dot whose suffix isn't
+    # a local one (LOCAL_NAME_SUFFIXES): `gpu.example.com` is remote, while
+    # `box`, `mac.local`, `gpu.lan` and `pc.tail1234.ts.net` are local. chi
+    # doesn't look names up; hosts.<name>.remote overrides either way.
+    def self.remote_address?(scheme, host)
+      return true if scheme.to_s == "https"
+
+      address = IPAddr.new(host.to_s.delete_prefix("[").delete_suffix("]"))
+      address = address.native if address.ipv4_mapped?
+      LOCAL_NETS.none? { |net| net.family == address.family && net.include?(address) }
+    rescue IPAddr::Error
+      remote_name?(host)
+    end
+
+    def self.remote_name?(host)
+      name = host.to_s.downcase.delete_suffix(".")
+      return false unless name.include?(".")
+
+      LOCAL_NAME_SUFFIXES.none? { |suffix| name == suffix || name.end_with?(".#{suffix}") }
+    end
+    private_class_method :remote_name?
+
+    # server.first_token_timeout, or nil when unset or unreadable.
+    def self.configured_first_token_timeout
+      Config.get("server.first_token_timeout")
+    rescue StandardError # degrade-ok: no configured limit; the host's own or the remote default applies
+      nil
+    end
+  end
+end

data/lib/samagotchi/host_registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "ipaddr"
 require_relative "config"
+require_relative "host_address"
 require_relative "log"
 require_relative "model_ref"
 require_relative "client"
@@ -88,11 +88,11 @@ module Samagotchi
       def dialect_profile = LLM::Dialect.for(dialect)
 
       # A provider on the network rather than a local server: hosts.<name>.remote
-      # when set, else by its address (HostRegistry.remote_address?). An API
+      # when set, else by its address (HostAddress.remote_address?). An API
       # key doesn't decide: a llama.cpp on the LAN can have one. A remote
       # host's model list is cached longer, it gets a first-token limit, and
       # it isn't asked for llama.cpp's /props.
-      def remote? = remote.nil? ? HostRegistry.remote_address?(scheme, host) : remote
+      def remote? = remote.nil? ? HostAddress.remote_address?(scheme, host) : remote
 
       def models_ttl = remote? ? REMOTE_CACHE_TTL_SECONDS : CACHE_TTL_SECONDS
 
@@ -102,7 +102,7 @@ module Samagotchi
       # and read_timeout catches a dead one). 0 turns it off.
       def first_token_limit
         seconds = first_token_timeout
-        seconds = HostRegistry.configured_first_token_timeout if seconds.nil?
+        seconds = HostAddress.configured_first_token_timeout if seconds.nil?
         seconds = remote? ? REMOTE_FIRST_TOKEN_TIMEOUT : nil if seconds.nil?
         seconds&.positive? ? seconds : nil
       end
@@ -115,13 +115,61 @@ module Samagotchi
       def openai_base_url = entry.openai_base_url
     end
 
+    # Raised when a client override is set on the shared registry (.current):
+    # every command and chi web's routes would then send through it.
+    class Shared < StandardError
+      def initialize(msg = "HostRegistry.current is shared: set a client override on a registry of your own") = super
+    end
+
     # A client that every target uses instead of its host's own (specs inject
     # a stub this way; the Engine/TUI `client:` keyword sets it).
-    attr_accessor :client_override
+    attr_reader :client_override
+
+    # @raise [Shared] on the shared registry (.current)
+    def client_override=(client)
+      raise Shared if @shared
+
+      @client_override = client
+    end
+
+    @current_mutex = Mutex.new
+
+    # The registry this process's commands and chi web share: one per
+    # process, built again when config.yml's hosts: no longer equal the ones
+    # it was built from (HostConfig.all, compared as read: the YAML read is
+    # mtime-cached), so a host added while chi web runs is listed on the next
+    # read, and its model lists, index and adapters are kept while hosts:
+    # stay. It doesn't rebuild on server.first_token_timeout or the
+    # server.host/port fallback entry: those are read at construction. It
+    # refuses a client override (Shared). An Engine and the TerminalUI take
+    # it once, at their start: a running worker keeps the hosts it started
+    # with.
+    # For any env but the process ENV (chi self's spec envs): a fresh
+    # registry on that env, never kept.
+    # @return [HostRegistry]
+    def self.current(env: ENV)
+      return new(env: env) unless env.equal?(ENV)
+
+      @current_mutex.synchronize do
+        hosts = HostConfig.all
+        if @current.nil? || hosts != @current_hosts
+          @current = new(hosts_config: hosts, shared: true)
+          @current_hosts = hosts
+        end
+        @current
+      end
+    end
+
+    # Forget the shared registry (specs: one per example).
+    def self.reset_current!
+      @current_mutex.synchronize { @current = @current_hosts = nil }
+    end
 
     # @param clock [#call, nil] monotonic seconds (specs)
-    def initialize(hosts_config: nil, env: ENV, client_override: nil, clock: nil)
+    # @param shared [Boolean] .current's own: refuses a client override
+    def initialize(hosts_config: nil, env: ENV, client_override: nil, clock: nil, shared: false)
       @client_override = client_override
+      @shared = shared
       @env = env
       @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
       @adapters = {}
@@ -155,45 +203,9 @@ module Samagotchi
 
     attr_reader :entries
 
-    # Loopback, private (RFC 1918, IPv6 unique local) and link-local nets.
-    LOCAL_NETS = %w[127.0.0.0/8 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10
-                    ::1/128 fc00::/7 fe80::/10].map { |net| IPAddr.new(net) }.freeze
-
-    # Name suffixes that stay on a home or office network: mDNS, the
-    # special-use and customary private names, router defaults (fritz.box)
-    # and Tailscale's MagicDNS. Compared on whole labels.
-    LOCAL_NAME_SUFFIXES = %w[localhost local lan home home.arpa internal intranet localdomain private corp test
-                             box ts.net].freeze
-
-    # Whether an address is remote: https, an http IP address outside the
-    # local nets (LOCAL_NETS), or an http name with a dot whose suffix isn't
-    # a local one (LOCAL_NAME_SUFFIXES): `gpu.example.com` is remote, while
-    # `box`, `mac.local`, `gpu.lan` and `pc.tail1234.ts.net` are local. chi
-    # doesn't look names up; hosts.<name>.remote overrides either way.
-    def self.remote_address?(scheme, host)
-      return true if scheme.to_s == "https"
-
-      address = IPAddr.new(host.to_s.delete_prefix("[").delete_suffix("]"))
-      address = address.native if address.ipv4_mapped?
-      LOCAL_NETS.none? { |net| net.family == address.family && net.include?(address) }
-    rescue IPAddr::Error
-      remote_name?(host)
-    end
-
-    def self.remote_name?(host)
-      name = host.to_s.downcase.delete_suffix(".")
-      return false unless name.include?(".")
-
-      LOCAL_NAME_SUFFIXES.none? { |suffix| name == suffix || name.end_with?(".#{suffix}") }
-    end
-    private_class_method :remote_name?
-
-    # server.first_token_timeout, or nil when unset or unreadable.
-    def self.configured_first_token_timeout
-      Config.get("server.first_token_timeout")
-    rescue StandardError
-      nil
-    end
+    # The env its hosts, aliases and saved lists are read with (ENV, or chi
+    # self's): what an EffectiveModel's ModelLookup reads every layer with.
+    attr_reader :env
 
     def default_entry
       @entries["default"] || @entries.values.first

data/lib/samagotchi/kernel_loop.rb

@@ -792,20 +792,24 @@ module Samagotchi
       turn.qwen_attempts = 0
       turn.qwen_partial = nil
       runs = []
+      # The batch's ids before it runs (each run's events carry its own):
+      # nothing appends to the conversation during a batch, so they are the
+      # ids the entry would get after it (spec/tool_ids_pin_spec.rb).
+      ids = ToolIds.next_ids(turn.conversation, calls.size)
       begin
         ToolResponse.run_batch(tool_runner, calls, context: @context, iteration: turn.iteration, emit: turn.emit,
-                                                   on_stream_event: turn.on_stream_event, cap: turn.cap) { |run, _| runs << run }
+                                                   on_stream_event: turn.on_stream_event, cap: turn.cap, ids: ids) { |run, _| runs << run }
       rescue Interrupt
         # A Ctrl-C mid-batch: the entry still answers every call (the
         # finished runs, then run_batch's interrupted ones), for #run to
         # hand on with the conversation.
-        turn.conversation << ToolResponse.joined(runs, ids: ToolIds.next_ids(turn.conversation, runs.size))
+        turn.conversation << ToolResponse.joined(runs, ids: ids.first(runs.size))
         raise
       end
       turn.tool_activity.concat(ToolResponse.activities(runs))
       # One entry for the batch: the capped outputs joined (ToolResponse.joined),
       # an id per run (ToolIds).
-      turn.conversation << ToolResponse.joined(runs, ids: ToolIds.next_ids(turn.conversation, runs.size))
+      turn.conversation << ToolResponse.joined(runs, ids: ids.first(runs.size))
       turn.pending_tool_calls = true
       :next
     end

data/lib/samagotchi/llm/chat_loop.rb

@@ -1132,10 +1132,13 @@ module Samagotchi
         def dispatch(tool_calls, iteration, cap)
           log_direct_deferred(tool_calls)
           calls = tool_calls.map { |tool_call| NativeToolNormalizer.normalize(tool_call) }
+          # The batch's ids before it runs (each run's events carry its own):
+          # the same as one next id per result as it lands
+          # (spec/tool_ids_pin_spec.rb).
+          ids = ToolIds.next_ids(@conversation, calls.size)
           runs = ToolResponse.run_batch(@loop.tool_runner, calls, context: @turn_context, 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,
-                                                      ids: ToolIds.next_ids(@conversation, 1))
+                                                                  on_stream_event: @on_stream_event, cap: cap, ids: ids) do |run, index|
+            @conversation << ToolResponse.single(run, tool_call_id: tool_calls[index].id, ids: [ids[index]])
           end
           @tool_activity.concat(ToolResponse.activities(runs))
         end

data/lib/samagotchi/llm_context_strategy.rb

@@ -148,10 +148,10 @@ module Samagotchi
     end
 
     # Where one value came from: :session, :model_setting, :host_setting
-    # or :config, and the place as a warning names it ("the session",
-    # "models: deepseek", "hosts entry 'box'", "llm_context.apply").
+    # or :config, and the place, named as the other settings name theirs
+    # ("session", "models: deepseek", "hosts.box", "llm_context.apply").
     Origin = Data.define(:source, :where)
-    SESSION_ORIGIN = Origin.new(source: :session, where: "the session")
+    SESSION_ORIGIN = Origin.new(source: :session, where: "session")
 
     # What a turn's strategy, apply rule and budget are, each with its
     # Origin (/llm-context, /stats, the web's info bar).
@@ -169,26 +169,22 @@ module Samagotchi
       end
     end
 
-    # The strategy for +target+'s turn.
-    # @param target [HostRegistry::ModelTarget, nil]
-    # @param names [Array<String>] HostRegistry#lookup_names
-    # @param models [Hash{String => ModelSettings}, nil] ModelSettings.all (specs)
+    # The strategy for +lookup+'s model's turn.
+    # @param lookup [ModelLookup] the model's layers (EffectiveModel#lookup)
     # @param session [Array<Symbol>, nil] the session's own layers ([]: none)
     # @param session_apply [Symbol, nil] the session's own apply rule
     # @param session_budget [Integer, nil] the session's own budget (0: off)
     # @return [Resolved]
-    def resolve(target, names:, models: nil, session: nil, session_apply: nil, session_budget: nil)
-      explain(target, names: names, models: models, session: session, session_apply: session_apply,
-                      session_budget: session_budget).resolved
+    def resolve(lookup, session: nil, session_apply: nil, session_budget: nil)
+      explain(lookup, session: session, session_apply: session_apply, session_budget: session_budget).resolved
     end
 
     # #resolve, with where each value came from.
     # @return [Explained]
-    def explain(target, names:, models: nil, session: nil, session_apply: nil, session_budget: nil)
-      models ||= ModelSettings.all
-      layers, source, where = layers_for(target, names, models, session)
-      apply, apply_origin = apply_for(target, names, models, session_apply)
-      budget, budget_origin = budget_for(target, names, models, session_budget)
+    def explain(lookup, session: nil, session_apply: nil, session_budget: nil)
+      layers, source, where = layers_for(lookup, session)
+      apply, apply_origin = apply_for(lookup, session_apply)
+      budget, budget_origin = budget_for(lookup, session_budget)
       resolved = resolved(layers, source, where).with(apply: apply, protect_steps: protect_steps,
                                                       stale_edits: Config.get(STALE_EDITS_SETTING) == true,
                                                       budget_tokens: budget)
@@ -196,79 +192,47 @@ module Samagotchi
                     budget_tokens: budget_origin)
     end
 
-    # A session's LLM context strategy, apply rule and budget, each with
-    # where it came from (Explained#summary), as its worker would resolve
-    # them; nil when they can't be (an unreadable config, a model that
-    # resolves nowhere). Resolves from config and the registry only: no
-    # network, no model call. What a session page, a session list's ctx %
-    # and a spawn-time check all read.
-    # @param session [Session, nil]
-    # @param registry [HostRegistry, nil] the hosts to resolve against;
-    #   HostRegistry.new by default (what the caller usually has)
-    # @return [Hash, nil] Explained#summary, symbol keys
-    def for_session(session, registry: nil)
-      return nil if session.nil?
-
-      # Here, not at the top: config.rb requires this file before ConfigFile
-      # exists, and effective_model.rb requires config.rb (via host_registry.rb).
-      require_relative "effective_model"
-      registry ||= HostRegistry.new
-      own = session.llm_context
-      EffectiveModel.of_session(session, registry: registry).llm_context_explained(own&.resolve_args || {})&.summary(own)
-    rescue StandardError
-      nil
-    end
-
-    # The budget a session's turns run under (for_session's :budget_tokens),
-    # nil when it is off or can't be resolved. What a session list's ctx %
-    # counts against, so a saved session's fill reads as the live meter.
-    # @param session [Session, nil]
-    # @param registry [HostRegistry, nil] see .for_session
-    # @return [Integer, nil]
-    def session_budget(session, registry: nil)
-      for_session(session, registry: registry)&.fetch(:budget_tokens, nil)
-    end
-
     # [the budget, its Origin]: the session's own first (0 there is off,
     # whatever the model says).
-    def budget_for(target, names, models, session_budget)
+    def budget_for(lookup, session_budget)
       return [session_budget.positive? ? session_budget : nil, SESSION_ORIGIN] unless session_budget.nil?
 
-      if (setting = ModelSettings.find(names, :llm_context_budget_tokens, models: models))
+      if (setting = lookup.model(:llm_context_budget_tokens))
         return [setting.value, Origin.new(source: :model_setting, where: "models: #{setting.key}")]
       end
 
-      budget = target&.entry&.llm_context_budget_tokens
-      return [budget, Origin.new(source: :host_setting, where: "hosts entry '#{target.entry.name}'")] if budget
+      budget = lookup.host(:llm_context_budget_tokens)
+      return [budget, Origin.new(source: :host_setting, where: "hosts.#{lookup.host_name}")] if budget
 
-      [parse_budget(Config.get(BUDGET_SETTING), BUDGET_SETTING), Origin.new(source: :config, where: BUDGET_SETTING)]
+      [parse_budget(lookup.global(BUDGET_SETTING).first, BUDGET_SETTING), Origin.new(source: :config, where: BUDGET_SETTING)]
     end
 
-    def layers_for(target, names, models, session)
+    def layers_for(lookup, session)
       return [session, :session, SESSION_ORIGIN.where] if session
 
-      if (setting = ModelSettings.find(names, :llm_context_strategy, models: models))
+      if (setting = lookup.model(:llm_context_strategy))
         return [setting.value, :model_setting, "models: #{setting.key}"]
       end
 
-      layers = target&.entry&.llm_context_strategy
-      return [layers, :host_setting, "hosts entry '#{target.entry.name}'"] if layers
+      layers = lookup.host(:llm_context_strategy)
+      return [layers, :host_setting, "hosts.#{lookup.host_name}"] if layers
 
-      [parse(Config.get(SETTING), SETTING) || [], :config, SETTING]
+      [parse(lookup.global(SETTING).first, SETTING) || [], :config, SETTING]
     end
 
     # [the apply rule, its Origin].
-    def apply_for(target, names, models, session_apply)
+    def apply_for(lookup, session_apply)
       return [session_apply, SESSION_ORIGIN] if session_apply
 
-      if (setting = ModelSettings.find(names, :llm_context_apply, models: models))
+      if (setting = lookup.model(:llm_context_apply))
         return [setting.value, Origin.new(source: :model_setting, where: "models: #{setting.key}")]
       end
 
-      apply = target&.entry&.llm_context_apply
-      return [apply, Origin.new(source: :host_setting, where: "hosts entry '#{target.entry.name}'")] if apply
+      apply = lookup.host(:llm_context_apply)
+      return [apply, Origin.new(source: :host_setting, where: "hosts.#{lookup.host_name}")] if apply
 
-      [parse_apply(Config.get(APPLY_SETTING), APPLY_SETTING) || DEFAULT_APPLY, Origin.new(source: :config, where: APPLY_SETTING)]
+      [parse_apply(lookup.global(APPLY_SETTING).first, APPLY_SETTING) || DEFAULT_APPLY,
+       Origin.new(source: :config, where: APPLY_SETTING)]
     end
 
     # llm_context.protect_steps: 0 or more (a negative one is the default).