samagotchi 0.66.0 → 0.68.0

data/lib/samagotchi/desktop/macos.rb

@@ -11,6 +11,7 @@ require_relative "../version"
 require_relative "../self_report"
 require_relative "../installed_gem"
 require_relative "../config"
+require_relative "../host_keys"
 require_relative "../redacted_inspect"
 
 module Samagotchi
@@ -48,6 +49,9 @@ module Samagotchi
       # top of it (MacOS.broadcast_timeout).
       BROADCAST_TRIAGE_DEADLINE = 20
       BROADCAST_MARGIN = 10
+      # The agent terminals the helper pastes into (AgentTerminal.swift):
+      # one launch-file section each, in this order.
+      TERMINALS = %w[kitty tmux].freeze
 
       # Runs a command without a shell; [output, success].
       class Runner
@@ -69,10 +73,36 @@ module Samagotchi
         { "listen_on" => listen_on, "binary" => get.call("kitty.binary").to_s, "agents" => agents }
       end
 
+      # The tmux: settings, or nil while tmux.enabled is off. The binary is
+      # tmux.binary, else the tmux on +env+'s PATH ("" when there is none:
+      # see #warnings); the socket dir is where tmux puts `-L` sockets
+      # ($TMUX_TMPDIR when it is a directory, else /tmp, then tmux-<uid>).
+      # Both are frozen at bake time, like the rest of the launch file.
+      def self.tmux_settings(get = Config.method(:get), env: ENV)
+        return nil unless get.call("tmux.enabled")
+
+        binary = get.call("tmux.binary").to_s.strip
+        binary = path_tmux(env) if binary.empty?
+        tmpdir = env["TMUX_TMPDIR"].to_s
+        tmpdir = "/tmp" if tmpdir.empty? || !File.directory?(tmpdir)
+        agents = get.call("tmux.agents").to_s.split("|").map(&:strip).reject(&:empty?)
+        { "binary" => binary, "socket_dir" => File.join(tmpdir, "tmux-#{Process.uid}"), "agents" => agents }
+      end
+
+      def self.path_tmux(env)
+        env["PATH"].to_s.split(File::PATH_SEPARATOR).reject(&:empty?).map { File.join(_1, "tmux") }
+                   .find { File.file?(_1) && File.executable?(_1) }.to_s
+      end
+
+      # Each switched-on terminal's settings by name ("kitty" => …).
+      def self.terminal_settings(get = Config.method(:get), env: ENV)
+        { "kitty" => kitty_settings(get), "tmux" => tmux_settings(get, env: env) }.compact
+      end
+
       # The helper as chi desktop and chi update make it: the settings it
       # bakes into the launch file read from the config.
       def self.from_config(register: true)
-        new(register: register, kitty: kitty_settings, broadcast_timeout: broadcast_timeout)
+        new(register: register, terminals: terminal_settings, broadcast_timeout: broadcast_timeout)
       end
 
       # Seconds the helper gives `chi broadcast` before it stops it: the
@@ -86,7 +116,7 @@ module Samagotchi
 
       def initialize(app_dir: nil, support_dir: nil, env: ENV, runner: Runner.new,
                      source_dir: SelfReport::SOURCE_DIR, ruby: RbConfig.ruby, version: VERSION,
-                     arch: nil, sources_dir: SOURCES_DIR, register: true, chi_path: nil, kitty: nil,
+                     arch: nil, sources_dir: SOURCES_DIR, register: true, chi_path: nil, terminals: {},
                      broadcast_timeout: nil)
         home = env["HOME"] || Dir.home
         @app_dir = app_dir || File.join(home, "Applications")
@@ -100,7 +130,7 @@ module Samagotchi
         @arch = arch
         @sources_dir = sources_dir
         @register = register
-        @kitty = kitty
+        @terminals = terminals
         @broadcast_timeout = broadcast_timeout
       end
 
@@ -114,13 +144,13 @@ module Samagotchi
       # What the helper runs: absolute ruby + chi (no shims, which need the
       # shell's PATH), and the allowlisted env. chi is an installed gem's
       # RubyGems wrapper (it activates the gem and outlives upgrades and
-      # `gem cleanup`), else this checkout's bin/chi. The kitty section only
-      # when kitty.listen_on is set; the broadcast timeout when given.
+      # `gem cleanup`), else this checkout's bin/chi. A section per terminal
+      # switched on (TERMINALS order); the broadcast timeout when given.
       def launch_config
         env = { "LANG" => LANG }
         ENV_ALLOWLIST.each { |name| env[name] = @env[name] unless @env[name].to_s.empty? }
         config = { "version" => @version, "argv" => [@ruby, @chi_path], "env" => env, "sources_sha" => sources_sha }
-        config["kitty"] = @kitty if @kitty
+        TERMINALS.each { |name| config[name] = @terminals[name] if @terminals[name] }
         config["broadcast_timeout"] = @broadcast_timeout if @broadcast_timeout
         config
       end
@@ -145,11 +175,12 @@ module Samagotchi
       end
 
       # The launch file names another chi version or path than this one, or
-      # other kitty settings or broadcast timeout: refresh_launch_file fixes
-      # that without a rebuild.
+      # other terminal settings or broadcast timeout: refresh_launch_file
+      # fixes that without a rebuild.
       def launch_outdated?
         launch = read_launch
-        launch["version"] != @version || Array(launch["argv"]) != launch_config["argv"] || launch["kitty"] != @kitty ||
+        launch["version"] != @version || Array(launch["argv"]) != launch_config["argv"] ||
+          TERMINALS.map { launch[_1] } != TERMINALS.map { @terminals[_1] } ||
           launch["broadcast_timeout"] != @broadcast_timeout
       end
 
@@ -163,10 +194,41 @@ module Samagotchi
       end
 
       def warnings
-        return [] unless File.file?(File.join(@source_dir, ".git"))
+        worktree = if File.file?(File.join(@source_dir, ".git"))
+                     ["chi runs from a linked git worktree (#{@source_dir}); the helper stops working once it is removed. " \
+                      "Install from the main checkout or a gem install."]
+                   end
+        Array(worktree) + terminal_warnings + host_key_warnings
+      end
 
-        ["chi runs from a linked git worktree (#{@source_dir}); the helper stops working once it is removed. " \
-         "Install from the main checkout or a gem install."]
+      # What a terminal section can't do as baked (chi update shows these
+      # too: they need no Keychain lookup).
+      def terminal_warnings
+        tmux = @terminals["tmux"]
+        return [] unless tmux && tmux["binary"].to_s.empty?
+
+        ["tmux.enabled but no tmux found on PATH: set tmux.binary"]
+      end
+
+      # Each configured host key (api_key_env:) and whether the helper's chi
+      # gets it: the helper's bare env has no keys, so only the Keychain's
+      # count (HostKeys). :keychain, :shell_only (set in this shell, not in
+      # the Keychain) or :unset. Hosts come from the config the helper's chi
+      # reads: the launch file's XDG_CONFIG_HOME when baked; disabled hosts
+      # are left out. @return [Array<Hash>] name:, hosts:, state:
+      def host_keys
+        baked = read_launch["env"]
+        dir = baked["XDG_CONFIG_HOME"] if baked.is_a?(Hash)
+        # Spelled out: Paths.config_home's ~ is this process's HOME, not @env's.
+        config_env = { "XDG_CONFIG_HOME" => dir.to_s.empty? ? File.join(@env["HOME"] || Dir.home, ".config") : dir }
+        hosts = ConfigFile.hosts_config(env: config_env).values.select(&:api_key_env).group_by(&:api_key_env)
+        hosts.map do |name, entries|
+          state = if HostKeys.from_keychain(name, env: @env) then :keychain
+                  elsif !@env[name].to_s.strip.empty? then :shell_only
+                  else :unset
+                  end
+          { name: name, hosts: entries.map(&:name), state: state }
+        end
       end
 
       def info_plist
@@ -248,7 +310,8 @@ module Samagotchi
           stale: stale?,
           baked_dirs: env.select { |name, _| name.start_with?("XDG_") },
           service: dump.include?(BUNDLE_ID),
-          running: running
+          running: running,
+          host_keys: host_keys
         )
       end
 
@@ -311,6 +374,14 @@ module Samagotchi
         @arch ||= RbConfig::CONFIG["host_cpu"] == "arm64" ? "arm64" : `uname -m`.strip
       end
 
+      def host_key_warnings
+        host_keys.reject { |key| key[:state] == :keychain }.map do |key|
+          where = key[:state] == :shell_only ? "is set in this shell only" : "is unset"
+          "#{key[:name]} #{where}: the helper's new sessions and model list won't reach host " \
+            "#{key[:hosts].join(", ")} until it is in the Keychain (#{HostKeys.store_command(key[:name])})"
+        end
+      end
+
       def read_launch
         launch = JSON.parse(File.read(launch_path))
         launch.is_a?(Hash) ? launch : {}

data/lib/samagotchi/desktop_command.rb

@@ -3,6 +3,7 @@
 require_relative "cli/command"
 require_relative "cli/flags"
 require_relative "desktop"
+require_relative "host_keys"
 
 module Samagotchi
   # `chi desktop install|upgrade|uninstall|status`: the native helper that
@@ -121,12 +122,22 @@ module Samagotchi
       dirs = s[:baked_dirs].empty? ? "(defaults)" : s[:baked_dirs].map { |name, value| "#{name}=#{value}" }.join(" ")
       service = s[:service] ? "registered" : "not registered (try chi desktop upgrade, or log out and back in)"
       running = s[:running] ? "running" : "not running (open -g \"#{s[:app_path]}\")"
-      @stdout.puts(format_rows([["Chi Helper", version], ["app", s[:app_path]], ["runs chi", launch],
-                                ["state dirs", dirs], ["service", service], ["hotkey", hotkey(s[:hotkey])],
-                                ["process", running], ["at login", login(s[:login])]]))
+      rows = [["Chi Helper", version], ["app", s[:app_path]], ["runs chi", launch], ["state dirs", dirs],
+              ["service", service], ["hotkey", hotkey(s[:hotkey])], ["process", running], ["at login", login(s[:login])]]
+      rows << ["host keys", host_keys(s[:host_keys])] unless Array(s[:host_keys]).empty?
+      @stdout.puts(format_rows(rows))
       0
     end
 
+    # `VAR keychain · VAR this shell only (security …)`: what the helper's chi gets.
+    def host_keys(keys)
+      keys.map do |key|
+        next "#{key[:name]} keychain" if key[:state] == :keychain
+
+        "#{key[:name]} #{key[:state] == :shell_only ? "this shell only" : "unset"} (#{HostKeys.store_command(key[:name])})"
+      end.join(" · ")
+    end
+
     def hotkey(state)
       return "unknown (the app writes it when it starts)" unless state
 

data/lib/samagotchi/effective_model.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require_relative "host_registry"
+require_relative "log"
+require_relative "context_window"
+require_relative "llm_context_strategy"
+require_relative "model_profile"
+require_relative "reasoning_history"
+require_relative "sampling_settings"
+require_relative "served_model"
+require_relative "steer_cut"
+require_relative "steer_cut_after"
+require_relative "thinking"
+require_relative "vision_support"
+
+module Samagotchi
+  # The model a session runs on, as set: the name (maybe an alias;
+  # HostRegistry#resolve applies it) and the name as typed at start or at
+  # the last /model. One value, swapped in one assignment, so a reader on
+  # another thread never pairs one model's name with another's typed name.
+  ModelChoice = Data.define(:name, :typed)
+
+  # The effective model resolved once (HostRegistry#resolve: its host and
+  # client, the id sent) with the names its models: entry may be under
+  # (HostRegistry#lookup_names), and its settings read from them. An
+  # immutable snapshot built per read, never kept across reads: config.yml,
+  # a model listing (which may move a bare id to another host) and another
+  # process's saved lists all change what a resolve gives without any
+  # /model. Frozen, so any thread may hold one.
+  #
+  # Each setting reader rescues its own failure and gives the fallback the
+  # Engine has always given (Unresolved); building one raises as
+  # HostRegistry#resolve does (the Engine's #model_setting gives the
+  # fallback then).
+  EffectiveModel = Data.define(:registry, :name, :typed, :target, :names) do
+    # @param registry [HostRegistry]
+    # @param choice [ModelChoice]
+    # @raise what HostRegistry#resolve raises
+    def self.of(registry, choice)
+      target = registry.resolve(choice.name)
+      new(registry: registry, name: choice.name, typed: choice.typed, target: target,
+          names: registry.lookup_names(choice.typed, resolved: choice.name, target: target))
+    end
+
+    # A saved session's model (no worker): its model name, the default when
+    # blank, and the name it was typed as.
+    # @param session [Session]
+    def self.of_session(session, registry:)
+      name = session.model_name.to_s.strip.empty? ? ModelProfile.required_model_name(nil) : session.model_name
+      of(registry, ModelChoice.new(name: name, typed: session.model_typed || name))
+    end
+
+    def entry = target.entry
+    def client = target.client
+    def bare = target.bare_model
+    def host_name = entry.name
+
+    # A chat host (api: openai or anthropic), whose loop uses no prompt profile.
+    def chat? = entry.chat?
+
+    # The resolved ref a session stores (ModelRef#ref): no resolve.
+    def ref = registry.model_ref(name).ref
+
+    # The configured request parameters (hosts: and models: sampling).
+    def sampling
+      SamplingSettings.for(target, names: names)
+    rescue StandardError => e
+      unresolved(:sampling_unresolved, e, SamplingSettings::EMPTY)
+    end
+
+    # "temperature=0.6 (hosts.work)", nil when none.
+    def sampling_summary
+      SamplingSettings.summary(target, names: names)
+    rescue StandardError => e
+      unresolved(:sampling_unresolved, e, nil)
+    end
+
+    # The thinking level (Thinking.resolve), the session's +own+ first.
+    def thinking(own:)
+      Thinking.resolve(target, names: names, session: own).first
+    rescue StandardError => e
+      unresolved(:thinking_unresolved, e, Thinking::DEFAULT)
+    end
+
+    # The thinking level with where it came from (SettingExplained), nil
+    # when it can't be resolved.
+    def thinking_explained(own:)
+      Thinking.explain(target, names: names, session: own)
+    rescue StandardError => e
+      unresolved(:thinking_unresolved, e, nil)
+    end
+
+    # What a thinking level change costs the prompt cache
+    # (Thinking.cache_cost); the block gives the prompt profile, asked only
+    # on a native host. Raises.
+    # @return [Symbol]
+    def thinking_cache_cost(&)
+      Thinking.cache_cost(target, profile: entry&.chat? ? nil : yield&.name)
+    end
+
+    # The reasoning_history level (ReasoningHistory.resolve), the session's
+    # +own+ first.
+    def reasoning_history(own:)
+      ReasoningHistory.resolve(target, names: names, session: own).first
+    rescue StandardError => e
+      unresolved(:reasoning_history_unresolved, e, ReasoningHistory::DEFAULT)
+    end
+
+    # The reasoning_history level with where it came from (SettingExplained);
+    # nil on a native host unless +native+ (its loop ignores the level), or
+    # when it can't be resolved.
+    def reasoning_history_explained(own:, native: false)
+      return nil unless native || entry&.chat?
+
+      ReasoningHistory.explain(target, names: names, session: own)
+    rescue StandardError => e
+      unresolved(:reasoning_history_unresolved, e, nil)
+    end
+
+    # "drop (models: qwen)"; nil for the default, on a native host, or when
+    # it can't be resolved.
+    def reasoning_history_summary(own:)
+      return nil unless entry&.chat?
+
+      level, source = ReasoningHistory.resolve(target, names: names, session: own)
+      source ? ReasoningHistory.label(level, source) : nil
+    rescue StandardError => e
+      unresolved(:reasoning_history_unresolved, e, nil)
+    end
+
+    # What a reasoning_history change from +from+ to +to+ costs the prompt
+    # cache, given +conversation+ (ReasoningHistory.cache_cost).
+    def reasoning_history_cache_cost(from, to, conversation:)
+      ReasoningHistory.cache_cost(from, to, target: target, conversation: conversation)
+    rescue StandardError => e
+      unresolved(:reasoning_history_unresolved, e, nil)
+    end
+
+    # [seconds, source] a cut waits for thinking (SteerCutAfter.resolve);
+    # the global and its name when it can't be resolved.
+    def steer_cut_after_explained
+      SteerCutAfter.resolve(target, names: names)
+    rescue StandardError => e
+      unresolved(:steer_cut_after_unresolved, e, [SteerCut.cut_after, "steer.cut_after"])
+    end
+
+    # The LLM context strategy with where each value came from
+    # (LLMContextStrategy.explain) under the session's +args+
+    # (LLMContextOverride#resolve_args), nil when it can't be resolved.
+    def llm_context_explained(args)
+      LLMContextStrategy.explain(target, names: names, **args)
+    rescue StandardError => e
+      unresolved(:llm_context_unresolved, e, nil)
+    end
+
+    # The LLM context layers its turns run under; [] when they can't be
+    # resolved.
+    def llm_context_layers(args)
+      LLMContextStrategy.resolve(target, names: names, **args).active_layers
+    rescue StandardError => e
+      unresolved(:llm_context_unresolved, e, [])
+    end
+
+    # models:/hosts: window_tokens (ContextWindow.setting), nil when unset.
+    def window_setting
+      ContextWindow.setting(target, names: names)
+    rescue StandardError => e
+      unresolved(:window_unresolved, e, nil)
+    end
+
+    # The window as its loop would see it (ChatLoop#context_window: a remote
+    # chat host has no /props, only its model list); nil when it can't be
+    # resolved.
+    def context_window
+      client = self.client
+      adapter = nil
+      if entry.chat?
+        adapter = registry.adapter_for(entry)
+        client = nil if adapter.remote?
+      end
+      ContextWindow.resolve(client: client, model: bare, adapter: adapter, setting: ContextWindow.setting(target, names: names))
+    rescue StandardError => e
+      unresolved(:window_unresolved, e, nil)
+    end
+
+    # Its price on its host (hosts.<name>.models.<id>.price), by the id
+    # asked for, never the one served; nil when none.
+    def price
+      entry.models&.dig(bare.to_s.strip.downcase)&.price
+    rescue StandardError => e
+      unresolved(:price_unresolved, e, nil)
+    end
+
+    # [served, +asked+] from llama.cpp's /props (one short cached probe),
+    # [nil, nil] for a remote chat host, without an answer, or when it
+    # can't be asked.
+    def served_from_props(asked)
+      if entry.chat? && registry.adapter_for(entry).remote?
+        return [nil, nil]
+      end
+
+      served = ServedModel.from_props(client.server_props(model: bare))
+      served ? [served, asked] : [nil, nil]
+    rescue StandardError => e
+      # The model resolved; asking its server failed (its /props, its adapter).
+      unresolved(:served_probe_failed, e, [nil, nil])
+    end
+
+    # The host whose hosts.<name>.models.<id>.served names +served+
+    # (ServedModel.expected_by), nil when none does.
+    def served_expected_by(served)
+      ServedModel.expected_by(target, served)
+    rescue StandardError => e
+      unresolved(:served_unresolved, e, nil)
+    end
+
+    # What a local native host's cached /props names when it isn't the
+    # model asked for; nil for a chat or remote host, or before any probe.
+    def prompt_served
+      return nil if entry.nil? || entry.chat? || entry.remote? || !client.respond_to?(:cached_server_props)
+
+      served = ServedModel.from_props(client.cached_server_props(model: bare))
+      served if ServedModel.differs?(bare, served)
+    rescue StandardError => e
+      unresolved(:served_unresolved, e, nil)
+    end
+
+    # Whether it sees images (VisionSupport.for) under +profile+.
+    def vision_support(profile)
+      VisionSupport.for(target, profile: profile, adapter: vision_adapter, names: names)
+    end
+
+    # A chat host's adapter (what it says of images), nil on a native host.
+    def vision_adapter
+      entry.chat? ? registry.adapter_for(entry) : nil
+    rescue StandardError => e
+      unresolved(:vision_adapter_unresolved, e, nil)
+    end
+
+    # Which prompt profile it gets (ModelProfile.resolve: may probe /props).
+    # Not cached here. Raises.
+    # @return [ModelProfile::Resolution]
+    def profile_resolution
+      ModelProfile.resolve(names: names, entry: entry, client: client, bare_model: bare)
+    end
+
+    # See Unresolved.fallback.
+    def unresolved(event, error, value) = EffectiveModel::Unresolved.fallback(event, self, error, value)
+    private :unresolved
+
+    # The name, typed name and host only: the default would print the
+    # registry and the client into any error message.
+    def inspect = "#<Samagotchi::EffectiveModel #{name.inspect} typed=#{typed.inspect} host=#{entry&.name.inspect}>"
+    alias_method :to_s, :inspect
+  end
+
+  class EffectiveModel
+    # The fallback an effective model's reader gives when its setting
+    # can't be resolved, with a log line: WARN the first time per process
+    # for an (event, model, error class), DEBUG after. The session state is
+    # read on every Bridge /state and SSE reset, so a broken host config
+    # would otherwise WARN per poll.
+    module Unresolved
+      @seen = Set.new
+      @mutex = Mutex.new
+
+      # @param event [Symbol] the log event (<setting>_unresolved)
+      # @param model [EffectiveModel, String] the model (or its name)
+      # @param error [StandardError]
+      # @return +value+
+      def self.fallback(event, model, error, value)
+        name = model.respond_to?(:name) ? model.name : model.to_s
+        first = @mutex.synchronize { @seen.add?([event, name, error.class.name]) }
+        fields = { model: name, error: error.class.name, msg: error.message.to_s[0, 200] }
+        first ? Log.warn(:model, event.to_s, **fields) : Log.debug(:model, event.to_s, **fields)
+        value
+      end
+
+      # Forget what was logged (specs).
+      def self.reset! = @mutex.synchronize { @seen.clear }
+    end
+  end
+end