samagotchi 0.63.0 → 0.65.0

data/lib/samagotchi/composer_route.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "delivery"
+
+module Samagotchi
+  # Where a line typed at a terminal's prompt goes, for both terminals (the
+  # REPL's TerminalUI#steer_line / #run_input_line, the attached
+  # AttachedLoop#submit). It only classifies; each UI keeps what it does
+  # with the answer (the REPL's mid-turn command policy and image lines, the
+  # attached TUI's continue offer and question). The web's composer.js
+  # routeComposerLine decides the same; spec/fixtures/composer_routes.json
+  # holds the cases both answer (docs/testing.md).
+  #
+  # In order:
+  #   1. /cut TEXT, /queue TEXT (.steer_choice), before every command check:
+  #      the bare word is :usage. While a turn runs TEXT is a :deliver with
+  #      its delivery (Delivery::CUT, Delivery::QUEUE); whether the worker
+  #      can queue is the UI's to check. With none running TEXT is routed
+  #      on as a line (step 2), its own /cut not read again.
+  #   2. A line: :empty; a terminal's own word (:local, the registry's
+  #      lookup_local id: :exit, :archive, :detach, :stats, :recap…); a
+  #      session command (:command); a typo of one (:typo, the hint in
+  #      +reply+); else :prompt. A line with images (+images+) is a message:
+  #      no command or typo check.
+  module ComposerRoute
+    CUT_COMMAND = "/cut"
+    QUEUE_COMMAND = "/queue"
+    # The word, then any whitespace and the text (as the registry's
+    # entries match them, so a line Tab or /help knows is never a prompt).
+    STEER_CHOICE = /\A(#{CUT_COMMAND}|#{QUEUE_COMMAND})(?:\s+(.*))?\z/m
+
+    KINDS = %i[empty usage deliver local command typo prompt].freeze
+
+    # @!attribute kind [Symbol] one of KINDS
+    # @!attribute text [String, nil] the line stripped: a /cut's or
+    #   /queue's own text, not the word
+    # @!attribute delivery [String, nil] a :deliver's Delivery value
+    # @!attribute reply [String, nil] a :typo's hint
+    # @!attribute local [Symbol, nil] a :local's registry id
+    # @!attribute choice [Symbol, nil] :cut or :queue when the line was
+    #   typed with that word (an idle one's text routed on keeps it)
+    Route = Data.define(:kind, :text, :delivery, :reply, :local, :choice) do
+      def initialize(kind:, text: nil, delivery: nil, reply: nil, local: nil, choice: nil)
+        super
+      end
+    end
+
+    # @param line [String, nil] as typed
+    # @param running [Boolean] a turn runs
+    # @param registry [Commands::Registry] the session's commands
+    # @param images [Integer] the attachments not in the text (the web's
+    #   chips); a terminal's @path images are its own to handle (0)
+    # @return [Route]
+    def self.call(line, running:, registry:, images: 0)
+      text = line.to_s.strip
+      choice, message = steer_choice(text)
+      return line_route(text, registry: registry, images: images) unless choice
+      return Route.new(kind: :usage, choice: choice) if message.empty?
+      return line_route(message, registry: registry, images: images).with(choice: choice) unless running
+
+      Route.new(kind: :deliver, text: message, delivery: choice == :cut ? Delivery::CUT : Delivery::QUEUE, choice: choice)
+    end
+
+    # The choice a line carries, as [:cut, "TEXT"] or [:queue, "TEXT"]; nil
+    # for any other line. The text is "" when the line named the choice
+    # without one.
+    # @param line [String, nil]
+    # @return [Array(Symbol, String), nil]
+    def self.steer_choice(line)
+      match = STEER_CHOICE.match(line.to_s.strip) or return nil
+
+      [match[1] == CUT_COMMAND ? :cut : :queue, match[2].to_s.strip]
+    end
+
+    def self.line_route(text, registry:, images:)
+      return Route.new(kind: :empty, text: text) if text.empty?
+
+      if images.zero?
+        local = registry.lookup_local(text)&.id
+        return Route.new(kind: :local, text: text, local: local) if local
+        return Route.new(kind: :command, text: text) if registry.command?(text)
+
+        hint = registry.unknown_command_hint(text)
+        return Route.new(kind: :typo, text: text, reply: hint) if hint
+      end
+      Route.new(kind: :prompt, text: text)
+    end
+    private_class_method :line_route
+  end
+end

data/lib/samagotchi/config.rb

@@ -279,7 +279,7 @@ module Samagotchi
     # Maps of named entries and the keys an entry may hold
     # (ConfigFile.hosts_config, ConfigFile.model_settings).
     MAP_ENTRY_KEYS = {
-      "hosts" => %w[host port url transport api api_key_env profile first_token_timeout vision sampling thinking
+      "hosts" => %w[host port url transport api api_key_env auth dialect profile first_token_timeout vision sampling thinking
                     reasoning_history enabled remote window_tokens steer_cut_after llm_context_strategy llm_context_apply llm_context_budget_tokens models].freeze,
       "models" => %w[profile vision sampling thinking reasoning_history window_tokens steer_cut_after llm_context_strategy llm_context_apply
                      llm_context_budget_tokens].freeze
@@ -851,13 +851,14 @@ module Samagotchi
 
     HOSTS_KEY = "hosts"
     VALID_TRANSPORTS_FOR_CONFIG = %w[llama_cpp mlx omlx].freeze
-    # How chi talks to a host: a raw-prompt api (also the Client transport) or
-    # openai, the chat loop against <host>/v1.
-    VALID_APIS_FOR_CONFIG = (VALID_TRANSPORTS_FOR_CONFIG + %w[openai]).freeze
+    # How chi talks to a host: a raw-prompt api (also the Client transport),
+    # or a chat api the chat loop talks (LLM::Adapters): openai (Chat
+    # Completions against <host>/v1) or anthropic (Messages).
+    VALID_APIS_FOR_CONFIG = (VALID_TRANSPORTS_FOR_CONFIG + %w[openai anthropic]).freeze
     HOST_NAME_RE = /\A[a-z0-9][a-z0-9._-]*\z/i
     ENV_NAME_RE = /\A[A-Za-z_][A-Za-z0-9_]*\z/
 
-    # config.yml's hosts: (or a worker's SAMAGOTCHI_HOSTS_JSON) by lowercased
+    # config.yml's hosts: (or a SAMAGOTCHI_HOSTS_JSON override) by lowercased
     # name; an entry that is disabled or invalid (warned) is left out. No
     # entry left: "default", from server.host/port/transport.
     # @return [Hash{String => HostConfig}]
@@ -914,7 +915,7 @@ module Samagotchi
 
     # The names (lowercased) of the hosts entries with enabled: false, which
     # hosts_config leaves out. Read from the same source: config.yml's
-    # hosts:, or SAMAGOTCHI_HOSTS_JSON in a worker.
+    # hosts:, or a SAMAGOTCHI_HOSTS_JSON override.
     # @return [Array<String>]
     def disabled_host_names(env: ENV, path: global_path(env: env))
       raw = hosts_source(read_yaml(env: env, path: path), env)
@@ -926,7 +927,8 @@ module Samagotchi
     end
 
     # config.yml's hosts: as written, or the SAMAGOTCHI_HOSTS_JSON override
-    # a worker inherits from its parent.
+    # set on this process (specs; SessionManager.spawn_options unsets it for
+    # a worker, which reads the file).
     def hosts_source(data, env)
       raw = data[HOSTS_KEY] if data.is_a?(Hash)
       env_json = env["SAMAGOTCHI_HOSTS_JSON"].to_s.strip
@@ -1041,6 +1043,8 @@ module Samagotchi
       hosts.keys.map { |k| k.to_s.downcase }.include?(prefix) ? nil : prefix
     end
 
+    # hosts_config as a SAMAGOTCHI_HOSTS_JSON override (workers no longer
+    # get one: they read config.yml).
     def hosts_json_for_env(env: ENV, path: global_path(env: env))
       hosts = hosts_config(env: env, path: path)
       # Only serialize if non-default or explicitly configured hosts:

data/lib/samagotchi/continue_offer.rb

@@ -85,12 +85,17 @@ module Samagotchi
     # Called with the event log held, before the command's command_ran. A
     # Stop runs no turn: last_turn says so (not_continued), so a wait on
     # it ends (chi answer --option Stop).
+    # It carries the offer turn's enqueued_id, so a wait on that turn
+    # (ReplyWait's turn:) ends on it too.
     def announce_resolved(result, command)
       @engine.announce(type: :continue_resolved, decision: result.decision.to_s, client_id: command.client_id)
       return if result.resume
 
       session = @engine.session
-      session.last_turn = LastTurn.new(outcome: NOT_CONTINUED, ended_at: Time.now.iso8601(3)) if session
+      return unless session
+
+      session.last_turn = LastTurn.new(outcome: NOT_CONTINUED, ended_at: Time.now.iso8601(3),
+                                       enqueued_id: offer_turn_id)
     end
 
     # After a command's command_ran and save: a /continue that answered the
@@ -117,9 +122,13 @@ module Samagotchi
     # asks again, one before the turn began too (logged, no :turn_failed).
     # The answer's text is carried into the turn as it begins; a turn that
     # never began leaves it to no other.
+    # The continue turn is the offer turn's: its origin carries that turn's
+    # enqueued_id, so its last_turn, its reply file and its checkpoint mark
+    # do too, and a wait on that turn (chi answer) gets its reply.
     def run_continue_turn(command)
       offer = @turn_flow.offer
       resume_from = @turn_flow.resume_from
+      enqueued_id = offer_turn_id
       close("answered")
       steer = @continue_steer
       @continue_steer = nil
@@ -131,8 +140,8 @@ module Samagotchi
           Log.warn(:worker, "turn_not_begun", continue: true, error: e.class.name, msg: e.message)
           return announce_offer(offer)
         end
-        @run_turn.call(nil, continue: true, origin: { client_id: command.client_id }.compact, resumed: true,
-                            resume_from: resume_from,
+        origin = { client_id: command.client_id, enqueued_id: enqueued_id }.compact
+        @run_turn.call(nil, continue: true, origin: origin, resumed: true, resume_from: resume_from,
                             max_iterations: @max_iterations.call(offer[:no_interrupt])) do |result, error|
           if error
             announce_offer(offer)
@@ -156,6 +165,11 @@ module Samagotchi
 
     private
 
+    # The enqueued_id of the turn the offer stands for: the exhausted
+    # turn's last_turn (a canceled continue turn's carries the same id);
+    # nil when it ran no input (a reminder turn, a delegate's first).
+    def offer_turn_id = @engine.session&.last_turn&.enqueued_id
+
     def announce_offer(offer = @turn_flow.offer)
       @engine.announce(type: :continue_offered, context: offer[:context], no_interrupt: offer[:no_interrupt])
       ask

data/lib/samagotchi/delivery.rb

@@ -23,25 +23,30 @@ module Samagotchi
     # Why a request body's delivery field can't be taken, as {error:,
     # detail:} for a 400, or nil when it can. The Bridge and the web's
     # POST /turn both ask this, so they refuse the same values. A missing
-    # or unknown string is not refused: it is the default (#parse). QUEUE
-    # is refused until a worker runs it (no worker reads it yet, so it
-    # would merge at the next step while the ack said queue).
+    # or unknown string is not refused: it is the default (#parse).
     # @param raw [Object] the wire value
     # @return [Hash, nil]
     def self.refusal(raw)
       return nil if raw.nil?
       return { error: "bad_delivery", detail: "delivery must be a string" } unless raw.is_a?(String)
-      return QUEUE_UNAVAILABLE if raw == QUEUE
 
       nil
     end
 
+    # The worker sidecar feature (Bridge::FEATURES) of a worker that runs
+    # all three values. One without it (before 0.64) ignores QUEUE, or
+    # refuses it with a 400 delivery_unavailable, so a sender checks it
+    # before sending a queue (SessionManager.deliver_turn, the attached TUI).
+    QUEUE_FEATURE = "delivery"
+
+    # The refusal for a queue a worker without QUEUE_FEATURE would steer
+    # (SessionManager.deliver_turn answers it as a 409). P0-P2 workers
+    # answer the same error code for a queue, with their own detail.
     QUEUE_UNAVAILABLE = {
-      error: "delivery_unavailable",
-      detail: "delivery queue isn't available yet; without it the message goes in at the running turn's next step " \
-              "(or runs as a turn when none runs)"
+      "error" => "delivery_unavailable",
+      "detail" => "this session's worker predates queueing, so the message would steer the running turn; " \
+                  "restart it (chi sessions restart ID, or the web's update badge) and send again"
     }.freeze
-    private_constant :QUEUE_UNAVAILABLE
 
     # Whether it is the one every sender defaulting to a step boundary uses.
     def self.next_step?(value) = parse(value) == NEXT_STEP

data/lib/samagotchi/engine.rb

@@ -224,6 +224,7 @@ module Samagotchi
       # and after a reminder turn), so the idle layer's clock is identical
       # across UIs.
       @turn_state.restart_clock!
+      @side_client_mutex = Mutex.new
       @recap = RecapSetup.build(recap, engine: self, host_registry: @host_registry,
                                 session_target: -> { session_model_recap_target },
                                 session_id: -> { @session&.id }, state_dir: -> { session_state_dir })
@@ -299,7 +300,7 @@ module Samagotchi
       # event[:ask_user], event[:stop_turn]): the Engine's routes to the UIs.
       @hooks.runtime = hook_runtime
       # The loop follows the effective model's host (its api:): the raw-prompt
-      # NativeBackend, or the chat backend for openai hosts.
+      # NativeBackend, or the chat backend for chat hosts (openai, anthropic).
       @native_backend = LLM::NativeBackend.new(kernel: @kernel)
     end
     private :wire_kernel
@@ -405,6 +406,10 @@ module Samagotchi
     # for #cut_for_steer.
     def input_epoch = @steer_cut.input_epoch
 
+    # The running generation's phase (SteerCut#generation_snapshot): what
+    # Bridge#snapshot puts in current_turn.generation.
+    def generation_snapshot = @steer_cut.generation_snapshot
+
     # Like #steer, for the turn that begins next (a continue turn answered
     # with a text): it joins that turn at its first boundary. Callable from
     # any thread; a turn that never begins keeps it for the next one, unless
@@ -1082,7 +1087,7 @@ module Samagotchi
       @last_context_status = saved_context_status(@metrics.snapshot[:context]) || @last_context_status if @last_context_status
     end
 
-    # The effective model is on a chat host (api: openai), whose loop uses
+    # The effective model is on a chat host (api: openai or anthropic), whose loop uses
     # no prompt profile.
     def chat_model? = @host_registry.resolve(@effective_model_name).entry.chat?
 
@@ -1433,8 +1438,10 @@ module Samagotchi
                elsif client_id == ClientId::REMINDER then "reminder"
                else "client"
                end
+      enqueued_id = origin.is_a?(Hash) ? origin[:enqueued_id] : nil
       session.last_turn = LastTurn.new(outcome: outcome, ended_at: Time.now.iso8601(3), seconds: seconds.round(1),
                                        origin: source, exhausted: limit ? true : nil, limit: limit,
+                                       enqueued_id: enqueued_id.to_s.empty? ? nil : enqueued_id.to_s,
                                        **stop_facts(event))
     end
 
@@ -2283,7 +2290,7 @@ module Samagotchi
       # A retry's nudge at the tail goes: this note says it all. An earlier
       # turn's note stays: it says why that turn ended.
       if result.empty_answer?
-        note = TurnNote.empty(retries: result.empty_retries, steps: result.empty_steps)
+        note = TurnNote.empty(retries: result.empty_retries, steps: result.empty_steps, refusal: result.refusal)
         conversation&.replace(TurnNote.without_trailing_nudge(conversation))
         saved = TurnNote.without_trailing_nudge(conversation || turn.session.messages)
         conversation << note if conversation
@@ -2480,6 +2487,15 @@ module Samagotchi
       nil
     end
 
+    # The host refused a sampling field (the empty-answer retry's
+    # temperature on a model that takes none) and the chat loop asked again
+    # without them, as it will for the model from now on: a log line.
+    def sampling_refused(event)
+      Log.info(:model, "sampling_refused", model: event[:model], detail: event[:detail])
+    rescue StandardError
+      nil
+    end
+
     # The host refused the model's reasoning sent back (reasoning_history)
     # and the chat loop asked the step again without it, as it will from
     # now on: logged, and said once per session and host.
@@ -2547,7 +2563,7 @@ module Samagotchi
         context_status: result.context_status&.dup
       }
       # No answer: every UI shows its notice (TurnNote.empty_answer_line).
-      summary[:empty_answer] = { retries: result.empty_retries.to_i } if result.empty_answer?
+      summary[:empty_answer] = { retries: result.empty_retries.to_i, refusal: result.refusal }.compact if result.empty_answer?
       summary
     end
 
@@ -2732,19 +2748,36 @@ module Samagotchi
 
     # ctx.ask_model's request: the session's current model on its host, as
     # a turn resolves them (a /model switch counts), through its own
-    # IdleClient, so it shares nothing with the turn's backend.
+    # IdleClient, so it shares nothing with the turn's backend. The client
+    # is kept while the target and timeout stay (what it learned, e.g. a
+    # refused thinking-off, holds for the next request); the session's id
+    # goes with the request.
     # @return [String] the answer
     def ask_side_model(request, timeout:, max_tokens:, cancel_controller:)
       target = session_model_recap_target
-      client = IdleClient.for(target, timeout: timeout)
+      client = side_model_client(target, timeout)
       started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      answer = client.ask(request, max_tokens: max_tokens, cancel_controller: cancel_controller)
+      answer = client.ask(request, max_tokens: max_tokens, cancel_controller: cancel_controller, session_id: @session&.id)
       Log.info(:plugins, "ask_model", model: target.label, answer_model: answer.model, chars: answer.text.length,
                                       ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round)
       answer.text
     end
     private :ask_side_model
 
+    # The IdleClient for +target+ at +timeout+: the last one when both are
+    # the same, else a new one.
+    def side_model_client(target, timeout)
+      @side_client_mutex.synchronize do
+        key = [target, timeout]
+        unless @side_client && @side_client_key == key
+          @side_client = IdleClient.for(target, timeout: timeout)
+          @side_client_key = key
+        end
+        @side_client
+      end
+    end
+    private :side_model_client
+
     # The session's current model as a recap target: its host's OpenAI API
     # (native llama.cpp hosts serve /v1/chat/completions too), key variable
     # and bare model name, as a turn resolves them.
@@ -2811,6 +2844,7 @@ module Samagotchi
         # reasoning sent back: a notice, not an event of its own.
         next thinking_refused(event) if event[:type] == :thinking_refused
         next reasoning_history_refused(event) if event[:type] == :reasoning_history_refused
+        next sampling_refused(event) if event[:type] == :sampling_refused
 
         event = with_generation_report(event) if event[:type] == :generation_completed
         emit_event(on_event, event)

data/lib/samagotchi/generation_phase.rb

@@ -14,6 +14,12 @@ module Samagotchi
     # A thinking delta this recent means the model is still thinking.
     FRESH_SECONDS = 2.0
 
+    # What a page joining mid-generation needs for its delivery line
+    # (Bridge#snapshot's current_turn.generation): whether it has streamed
+    # only thinking so far (thinking, no text, no tool call; freshness
+    # aside) and its thinking's #age (nil before any thinking).
+    Snapshot = Data.define(:thinking_only, :age)
+
     # @param clock [#call] monotonic seconds
     def initialize(clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       @clock = clock
@@ -71,6 +77,17 @@ module Samagotchi
       @mutex.synchronize { @running && @thinking_since ? @clock.call - @thinking_since : nil }
     end
 
+    # The running generation as a Snapshot, its age rounded to a tenth;
+    # nil with none running.
+    def snapshot
+      @mutex.synchronize do
+        next nil unless @running
+
+        age = @thinking_since && (@clock.call - @thinking_since).round(1)
+        Snapshot.new(thinking_only: !@thinking_since.nil? && !@text && !@tool_call, age: age)
+      end
+    end
+
     private
 
     def clear_seen

data/lib/samagotchi/host_config.rb

@@ -4,29 +4,38 @@ require "uri"
 require_relative "config"
 require_relative "host_model"
 require_relative "llm_context_strategy"
+require_relative "llm/dialect"
 require_relative "reasoning_history"
 
 module Samagotchi
   # One config.yml hosts: entry, parsed and checked (ConfigFile.hosts_config
   # holds them by lowercased name; HostRegistry builds its HostEntry from
-  # one). A worker gets its parent's hosts back through
-  # SAMAGOTCHI_HOSTS_JSON: #to_env_h writes every field, and .parse reads
-  # it back to an equal HostConfig.
+  # one). #to_env_h writes every field in the shape of the
+  # SAMAGOTCHI_HOSTS_JSON override (ConfigFile.hosts_json_for_env), and
+  # .parse reads it back to an equal HostConfig.
   #
   # name: the lowercased entry name; host, port, scheme: where it is (from
   # url: when given); url: the configured url, nil when host/port; transport,
-  # api: symbols, nil when unset; the rest as HostRegistry::HostEntry
-  # describes them, nil when unset; models: {downcased id => HostModel}.
-  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :profile,
+  # api: symbols, nil when unset; auth: the header the API key goes in
+  # (LLM::ApiKey::SCHEMES), nil when unset; dialect: an api: anthropic
+  # host's LLM::Dialect name, nil when unset; the rest as
+  # HostRegistry::HostEntry describes them, nil when unset; models:
+  # {downcased id => HostModel}.
+  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :transport, :api, :api_key_env, :auth, :dialect, :profile,
                            :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models) do
+    # An api: anthropic host without url/host talks to Anthropic's own API.
+    ANTHROPIC_URL = "https://api.anthropic.com"
+    # auth: as written => the LLM::ApiKey scheme.
+    AUTH_SCHEMES = { "bearer" => :bearer, "x-api-key" => :x_api_key }.freeze
+
     # Every field but name may be left out: nil, models {}.
     def initialize(**fields)
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
     end
 
-    # A hosts: entry as written (YAML, or a worker's SAMAGOTCHI_HOSTS_JSON),
+    # A hosts: entry as written (YAML, or a SAMAGOTCHI_HOSTS_JSON override),
     # or nil when it is disabled (enabled: false) or invalid. An invalid
     # one warns once, naming the entry, the way each reader of a setting
     # does for a bad value (that value is then unset).
@@ -69,8 +78,17 @@ module Samagotchi
         return invalid(name, "api_key_env must be an environment variable name")
       end
 
-      location = parse_location(name, value) or return nil
+      auth = value.call(:auth).to_s.strip.downcase
+      fields[:auth] = AUTH_SCHEMES[auth] unless auth.empty?
+      return invalid(name, "auth must be one of #{AUTH_SCHEMES.keys.join(", ")}") if !auth.empty? && fields[:auth].nil?
+
+      if fields[:auth] && fields[:api_key_env].nil?
+        ConfigFile.warn_once "Warning: #{where}: auth has no effect without api_key_env (no key is sent)"
+      end
+
       kinds = parse_kinds(name, value.call(:transport), value.call(:api)) or return nil
+      location = parse_location(name, value, api: kinds[:api]) or return nil
+      fields[:dialect] = LLM::Dialect.parse(value.call(:dialect), where, api: kinds[:api])
       new(name: name.downcase, **location, **kinds, **fields)
     rescue StandardError => e
       # One entry that trips a reader is dropped on its own, and said so;
@@ -99,11 +117,13 @@ module Samagotchi
     end
 
     # host/port/scheme/url from url:, or from host: and port:; nil (warned)
-    # when they are wrong.
-    def self.parse_location(name, value)
+    # when they are wrong. An api: anthropic entry with neither has
+    # ANTHROPIC_URL.
+    def self.parse_location(name, value, api: nil)
       host = value.call(:host)
       port = value.call(:port)
       url = value.call(:url).to_s.strip
+      url = ANTHROPIC_URL if url.empty? && api == :anthropic && host.to_s.strip.empty? && port.to_s.strip.empty?
       scheme = "http"
       unless url.empty?
         return invalid(name, "give url or host/port, not both") unless host.to_s.strip.empty? && port.to_s.strip.empty?
@@ -160,14 +180,15 @@ module Samagotchi
     end
     private_class_method :invalid
 
-    # The entry as a worker's SAMAGOTCHI_HOSTS_JSON carries it (string keys,
+    # The entry as a SAMAGOTCHI_HOSTS_JSON override carries it (string keys,
     # unset fields left out); .parse(name, to_env_h) gives it back. A url
     # entry travels as its url (host/port come from it); the API key stays
-    # in the environment, which workers inherit.
+    # in the environment.
     # @return [Hash{String => Object}]
     def to_env_h
       location = url ? { "url" => url } : { "host" => host, "port" => port }
       location.merge("transport" => transport&.to_s, "api" => api&.to_s, "api_key_env" => api_key_env,
+                     "auth" => (AUTH_SCHEMES.key(auth) if auth), "dialect" => dialect,
                      "profile" => profile, "first_token_timeout" => first_token_timeout,
                      "vision" => vision, "sampling" => sampling, "thinking" => thinking&.to_s,
                      "reasoning_history" => reasoning_history&.to_s, "remote" => remote, "window_tokens" => window_tokens,

data/lib/samagotchi/host_model.rb

@@ -104,8 +104,8 @@ module Samagotchi
       end
     end
 
-    # The entry as written back to config (SAMAGOTCHI_HOSTS_JSON for
-    # workers): nil for a bare id.
+    # The entry as written back to config (HostConfig#to_env_h): nil for a
+    # bare id.
     def to_config
       config = { "price" => price&.to_config, "served" => served }.compact
       config unless config.empty?

data/lib/samagotchi/host_registry.rb

@@ -6,7 +6,8 @@ require_relative "log"
 require_relative "model_ref"
 require_relative "client"
 require_relative "model_list_store"
-require_relative "llm/openai_chat"
+require_relative "llm/adapters"
+require_relative "llm/dialect"
 
 module Samagotchi
   # HostRegistry manages multiple model hosts (llama.cpp / mlx / oMLX) and
@@ -30,6 +31,8 @@ module Samagotchi
 
     # url: the configured url, when the entry has one (host, port and scheme
     # come from it); api_key_env: the variable holding the host's API key;
+    # auth: the header it goes in (LLM::ApiKey::SCHEMES), nil for the api's own default;
+    # dialect: an api: anthropic host's LLM::Dialect name (#dialect_profile), nil when unset;
     # profile: the configured prompt profile name, if any;
     # first_token_timeout: the configured first-token limit (see #first_token_limit);
     # vision: the configured true/false (VisionSupport), nil when unset;
@@ -43,13 +46,13 @@ module Samagotchi
     # llm_context_apply: the configured apply rule (LLMContextStrategy), nil when unset;
     # llm_context_budget_tokens: the configured context budget (LLMContextStrategy), nil when unset;
     # models: the ids the host serves whatever it lists, {downcased id => HostModel} ({} when none).
-    HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :profile,
-                           :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
+    HostEntry = Struct.new(:name, :host, :port, :transport, :client, :api, :scheme, :url, :api_key_env, :auth, :dialect,
+                           :profile, :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models, keyword_init: true) do
-      # Talks the OpenAI chat API (the chat loop); nil and raw apis use the
-      # raw-prompt loop.
-      def chat? = api == :openai
+      # Talks a chat API through an adapter (LLM::Adapters: the chat loop);
+      # nil and raw apis use the raw-prompt loop.
+      def chat? = LLM::Adapters.chat_api?(api)
 
       # The server root, e.g. for llama.cpp's own endpoints and recap.
       def root_url = "#{scheme || "http"}://#{host}:#{port}"
@@ -58,6 +61,25 @@ module Samagotchi
       # configured, else the root's /v1.
       def openai_base_url = url || "#{root_url}/v1"
 
+      # The API base the host's chat adapter talks to (LLM::Adapters): for
+      # api: openai the OpenAI-compatible base; for api: anthropic the API
+      # root without /v1 (as ANTHROPIC_BASE_URL; a url that ends in /v1
+      # loses it, so requests never go to /v1/v1).
+      def api_base_url
+        return openai_base_url unless api&.to_sym == :anthropic
+
+        (url || root_url).chomp("/").delete_suffix("/v1")
+      end
+
+      # The header the host's key goes in: auth: when set, else the api's
+      # own (for api: anthropic its dialect's, x-api-key unless the dialect
+      # says otherwise; Bearer for every other api).
+      def auth_scheme = auth || (api&.to_sym == :anthropic ? dialect_profile.auth : :bearer)
+
+      # The LLM::Dialect an api: anthropic host's requests follow (STANDARD
+      # when it names none).
+      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
       # key doesn't decide: a llama.cpp on the LAN can have one. A remote
@@ -106,7 +128,7 @@ module Samagotchi
         entry = HostEntry.new(**fields)
         entry.client = Client.new(host: cfg.host, port: cfg.port, transport: cfg.transport, scheme: cfg.scheme,
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
-                                  api_key_env: entry.api_key_env, env: env)
+                                  api_key_env: entry.api_key_env, auth: entry.auth_scheme, env: env)
         @entries[entry.name] = entry
       end
       # Fallback single entry (should already be synthesized by hosts_config, but guard)
@@ -217,12 +239,13 @@ module Samagotchi
     end
 
     # The chat adapter for a host (one per host, so its cached model list
-    # serves the context window). Only chat hosts use it for turns.
+    # serves the context window), as LLM::Adapters builds it for the host's
+    # api. Only chat hosts use it for turns.
     # @return [LLM::OpenAIChat]
     def adapter_for(entry)
       @mutex.synchronize do
-        @adapters[entry.name] ||= LLM::OpenAIChat.for(entry, models_ttl: entry.models_ttl,
-                                                             first_token_timeout: entry.first_token_limit)
+        @adapters[entry.name] ||= LLM::Adapters.for(entry, models_ttl: entry.models_ttl,
+                                                           first_token_timeout: entry.first_token_limit)
       end
     end
 
@@ -390,7 +413,7 @@ module Samagotchi
     # the registry).
     def inspect
       hosts = @entries.values.map do |entry|
-        parts = [entry.openai_base_url]
+        parts = [entry.api_base_url]
         parts << "key=#{entry.api_key_env}" if entry.api_key_env
         parts << "models=#{entry.models.values.map(&:id).join(",")}" unless entry.models.empty?
         "#{entry.name}(#{parts.join(" ")})"