samagotchi 0.93.0 → 0.95.0

data/lib/samagotchi/client.rb

@@ -12,14 +12,13 @@ require_relative "vision_support"
 require_relative "sampling_settings"
 
 module Samagotchi
-  # Thin HTTP client for llama.cpp's native /completion endpoint, or an
-  # OpenAI-compatible /v1/completions endpoint (e.g. mlx_lm.server or oMLX).
+  # Thin HTTP client for llama.cpp's native /completion endpoint (chi's
+  # raw-prompt loop; any other server is a chat host, api: openai).
   # Configured by the server.* settings (Samagotchi::Config):
   #   server.host  (default: localhost)
-  #   server.port  (default: 8080; oMLX's default is 8000, set it to match)
+  #   server.port  (default: 8080)
   #   server.open_timeout (default: 10 seconds)
   #   server.read_timeout (default: 600 seconds)
-  #   server.transport (llama_cpp|mlx|omlx, default: llama_cpp)
   class Client
     # The shared HTTP layer's errors, under their old names.
     RequestCancelled = LLM::RequestCancelled
@@ -36,8 +35,13 @@ module Samagotchi
     # #clear_props_failures!).
     PROPS_FAILURE_TTL = 30
 
-    DEFAULT_TRANSPORT = :llama_cpp
-    VALID_TRANSPORTS = %i[llama_cpp mlx omlx].freeze
+    # llama.cpp's native API: the name in error lines (when the host has
+    # none) and its endpoints. llama.cpp's /props carries the per-slot
+    # n_ctx (-c split across --parallel slots) and the chat template.
+    LABEL = "llama.cpp"
+    COMPLETION_PATH = "/completion"
+    MODELS_PATH = "/models"
+    PROPS_PATH = "/props"
 
     # One /props cache per host per process. A host has more than one Client
     # in a run (the registry's, a rebuilt HostRegistry's, the Engines of a
@@ -64,98 +68,30 @@ module Samagotchi
       end
     end
 
-    # Wire-format strategy for one server transport. `Client` keeps the
-    # transport-agnostic request/retry/stream loop; everything that differs
-    # between llama.cpp's native API and the OpenAI-compatible servers
-    # (mlx_lm.server, oMLX) lives here: endpoint paths, payload keys, streamed
-    # content parsing, and the request's `model` field semantics.
-    class Transport
-      attr_reader :name
-
-      # @param name [Symbol] one of Client::VALID_TRANSPORTS
-      # @param model_resolver [Proc, nil] client-installed resolver for the
-      #   request's `model` field (oMLX resolves against its /v1/models list;
-      #   mlx installs one that always returns nil to omit the field); nil
-      #   means forward the selector verbatim (llama.cpp default)
-      def initialize(name, model_resolver: nil)
-        @name = name
-        @model_resolver = model_resolver
-      end
-
-      def label
-        # oMLX gets its own label so its error paths read "omlx ...", not "mlx ...".
-        @name == :llama_cpp ? "llama.cpp" : @name.to_s
-      end
-
-      def completion_path
-        openai_compatible? ? "/v1/completions" : "/completion"
-      end
-
-      def models_path
-        openai_compatible? ? "/v1/models" : "/models"
-      end
-
-      def token_limit_key
-        openai_compatible? ? :max_tokens : :n_predict
-      end
-
-      # Where the server describes itself (context window, chat template), or
-      # nil when it has no such route. llama.cpp's /props carries the per-slot
-      # n_ctx (-c split across --parallel slots) and the chat template.
-      # mlx_lm.server and oMLX expose neither.
-      def props_path
-        openai_compatible? ? nil : "/props"
-      end
-
-      def context_window_from(body)
-        n_ctx = body.is_a?(Hash) ? body.dig("default_generation_settings", "n_ctx") : nil
-        n_ctx.is_a?(Integer) && n_ctx.positive? ? n_ctx : nil
-      end
-
-      # Text content carried by one streamed `data:` payload.
-      def content_from_payload(payload)
-        openai_compatible? ? payload.dig("choices", 0, "text").to_s : payload.fetch("content", "")
-      end
+    # The context window (n_ctx) in a /props body, or nil.
+    def self.context_window_from(body)
+      n_ctx = body.is_a?(Hash) ? body.dig("default_generation_settings", "n_ctx") : nil
+      n_ctx.is_a?(Integer) && n_ctx.positive? ? n_ctx : nil
+    end
 
-      # Why the stream stopped, from its last payload, as an OpenAI finish
-      # reason ("length" for the token cap or a full context, "stop"
-      # otherwise); nil for a payload that doesn't say. llama.cpp's
-      # /completion names it stop_type ("limit", "eos", "word"); the
-      # OpenAI-compatible servers send their own finish_reason.
-      def finish_reason_from(payload)
-        return nil unless payload.is_a?(Hash)
-        return payload.dig("choices", 0, "finish_reason") if openai_compatible?
-
-        case payload["stop_type"]
-        when "limit" then "length"
-        when "eos", "word" then "stop"
-        end
-      end
+    # Why the stream stopped, from its last payload, as an OpenAI finish
+    # reason ("length" for the token cap or a full context, "stop"
+    # otherwise); nil for a payload that doesn't say. llama.cpp's
+    # /completion names it stop_type ("limit", "eos", "word").
+    def self.finish_reason_from(payload)
+      return nil unless payload.is_a?(Hash)
 
-      # The request's `model` field for this transport (nil = omit the field):
-      #   - llama.cpp: forward the selector (SAMAGOTCHI_DEFAULT_MODEL) verbatim.
-      #   - mlx_lm.server: omit `model` entirely (use whatever was loaded via the
-      #     server's own `--model` CLI flag).
-      #   - oMLX: MUST send a model id that exists in the server's `/v1/models`
-      #     list, or oMLX 400s with "model: Field required". The client-installed
-      #     resolver maps the short selector (e.g. `gemma-4-26b-a4b-it-4bit`) to
-      #     the exact registered id (which may be prefixed, e.g.
-      #     `mlx-community--...`) by matching against the loaded /v1/models list.
-      def model_for_payload(model)
-        return @model_resolver.call(model) if @model_resolver
-
-        value = model.to_s.strip
-        value.empty? ? nil : value
+      case payload["stop_type"]
+      when "limit" then "length"
+      when "eos", "word" then "stop"
       end
+    end
 
-      # llama.cpp's own API: slots (`id_slot`), `cache_prompt`, /props.
-      def native? = @name == :llama_cpp
-
-      private
-
-      def openai_compatible?
-        @name == :mlx || @name == :omlx
-      end
+    # The request's `model` field: the selector verbatim, nil (omit the
+    # field) when blank.
+    def self.model_for_payload(model)
+      value = model.to_s.strip
+      value.empty? ? nil : value
     end
 
     # One /props probe's outcome. `answered?` is false when the probe failed:
@@ -191,14 +127,14 @@ module Samagotchi
     # @param first_token_timeout [Numeric, nil] seconds a completion may take
     #   to stream its first text (LLM::HTTP); nil: no limit
     # @param name [String, nil] the host's config name, for error lines
-    #   (default: the transport's label)
+    #   (default: LABEL)
     # @param api_key_env [String, nil] the variable holding the host's API
     #   key (llama.cpp's --api-key), sent as a bearer token on every request;
     #   nil sends no Authorization header
     # @param auth [Symbol, nil] the header the key goes in (LLM::ApiKey::SCHEMES;
     #   HostEntry#auth_scheme), nil: Bearer
     # @param env [Hash] where the key variable is read
-    def initialize(host: nil, port: nil, open_timeout: nil, read_timeout: nil, transport: nil, sleeper: nil, scheme: nil,
+    def initialize(host: nil, port: nil, open_timeout: nil, read_timeout: nil, sleeper: nil, scheme: nil,
                    first_token_timeout: nil, name: nil, api_key_env: nil, auth: nil, env: ENV)
       # Unified config precedence: CLI > ENV > file > default (via Samagotchi::Config)
       @host          = host || Samagotchi::Config.get("server.host")
@@ -206,7 +142,6 @@ module Samagotchi
       @scheme        = scheme || "http"
       @open_timeout  = Samagotchi::Config.positive_seconds("server.open_timeout", open_timeout)
       @read_timeout  = Samagotchi::Config.positive_seconds("server.read_timeout", read_timeout)
-      @transport = build_transport(resolve_transport(transport))
       # This host's process-wide /props entry (see self.props_entry): its
       # answers and failures are shared with every other Client of the same
       # server.
@@ -216,7 +151,7 @@ module Samagotchi
       @props_mutex = @props_entry[:mutex]
       @first_token_timeout = first_token_timeout
       @host_name = name
-      @label = name.to_s.empty? ? @transport.label : name.to_s
+      @label = name.to_s.empty? ? LABEL : name.to_s
       @http = LLM::HTTP.new(label: @label, open_timeout: @open_timeout, read_timeout: @read_timeout,
                             sleeper: sleeper, first_token_timeout: first_token_timeout,
                             api_key: LLM::ApiKey.for(api_key_env, host: @label, env: env, scheme: auth))
@@ -228,9 +163,6 @@ module Samagotchi
     # The host's config name, or nil when built without one.
     attr_reader :host_name
 
-    # The wire-format strategy for this client's transport.
-    attr_reader :transport
-
     # Send a raw prompt and return the model's completion text.
     #
     # llama.cpp can stream completion chunks as newline-delimited `data: {...}`
@@ -286,23 +218,20 @@ module Samagotchi
 
     # Prefill +prompt+ and keep it in the server's cache, so the next
     # request that starts with it only prefills what follows (PromptWarmup:
-    # the turn-end warm-up). llama.cpp's native /completion only; nil on
-    # any other transport. One non-streamed request generating one token
+    # the turn-end warm-up). One non-streamed request generating one token
     # (n_predict 0 does the same on current builds, 1 on every one): no
     # retries, no first-token limit, no stream events. Errors are raised.
     # @param slot [Integer, nil] the slot to run on (`id_slot`): the one the
     #   last request used, which still holds its state
     # @param images [Array<String>] as #complete's
-    # @return [Warmup, nil]
+    # @return [Warmup]
     def warm_up(prompt, model: nil, slot: nil, images: [])
-      return nil unless @transport.native?
-
       images = Array(images)
       text = LLM::Utf8Scrub.call(images.empty? ? prompt : prompt.gsub(ImagePlan::NATIVE_PLACEHOLDER, media_marker!(model)))
       payload = { prompt: images.empty? ? text : { prompt_string: text, multimodal_data: images },
                   n_predict: 1, cache_prompt: true, stream: false }
       payload[:id_slot] = slot if slot.is_a?(Integer)
-      model_name = @transport.model_for_payload(model)
+      model_name = Client.model_for_payload(model)
       payload[:model] = model_name if model_name
       uri = completion_uri
       request = Net::HTTP::Post.new(uri)
@@ -317,13 +246,13 @@ module Samagotchi
 
     # Whether llama.cpp's slot +slot+ is processing a request now (GET
     # /slots, its is_processing): :busy or :idle. nil when unknown: no slot,
-    # another transport, the endpoint off (--no-slots), a slot it doesn't
+    # the endpoint off (--no-slots), a slot it doesn't
     # list, a bad body or a network error. One quick attempt (PromptWarmup:
     # a warm-up pinned to a busy slot waits behind that request, and the
     # next turn behind the warm-up).
     # @return [Symbol, nil]
     def slot_status(slot, model: nil)
-      return nil unless @transport.native? && slot.is_a?(Integer)
+      return nil unless slot.is_a?(Integer)
 
       model = model.to_s.strip
       query = model.empty? ? "" : "?#{URI.encode_www_form(model: model)}"
@@ -368,7 +297,7 @@ module Samagotchi
         next unless on_chunk
 
         chunk = { content: content, payload: payload }
-        finish_reason = @transport.finish_reason_from(payload)
+        finish_reason = Client.finish_reason_from(payload)
         chunk[:finish_reason] = finish_reason if finish_reason
         on_chunk.call(**chunk)
       end
@@ -378,26 +307,26 @@ module Samagotchi
       clear_props_failures!
       result
     rescue LLM::BadRequest => e
-      raise unless e.status == 404 && @transport.name == :llama_cpp
+      raise unless e.status == 404
 
       # No native /completion here: likely an OpenAI-compatible server.
       raise LLM::BadRequest.new(e.message, host: e.host, status: e.status, attempts: e.attempts, hint: OPENAI_API_HINT)
     rescue RequestCancelled, LLM::ProviderError
       raise
     rescue StandardError => e
-      raise "#{@transport.label} request failed (#{@host}:#{@port}): #{e.message}"
+      raise "#{LABEL} request failed (#{@host}:#{@port}): #{e.message}"
     end
 
     # The running llama.cpp's media marker (/props), or a VisionUnsupported.
     def media_marker!(model)
-      marker = @transport.props_path && VisionSupport.media_marker(server_props(model: model))
+      marker = VisionSupport.media_marker(server_props(model: model))
       return marker if marker
 
       raise LLM::VisionUnsupported.new("#{@label}: can't reach /props for the media marker", host: @label)
     end
 
     def list_models
-      uri = URI("#{@scheme}://#{@host}:#{@port}#{@transport.models_path}")
+      uri = URI("#{@scheme}://#{@host}:#{@port}#{MODELS_PATH}")
       response = @http.fetch(uri, Net::HTTP::Get.new(uri), log_fields: { purpose: "models" })
       clear_props_failures!
       parsed = JSON.parse(response.body.to_s)
@@ -405,11 +334,11 @@ module Samagotchi
     rescue LLM::ProviderError
       raise
     rescue StandardError => e
-      raise "#{@transport.label} model listing failed (#{@host}:#{@port}): #{e.message}"
+      raise "#{LABEL} model listing failed (#{@host}:#{@port}): #{e.message}"
     end
 
-    # What the running server says about itself (/props), as a ServerProps,
-    # or nil when the transport has no such route. One GET with short
+    # What the running server says about itself (/props), as a ServerProps.
+    # One GET with short
     # timeouts and no retry: it runs before generation and must never hold up
     # a turn. The probe names the model (`?model=`): a llama.cpp router
     # answers a stub without it, and a single-model server ignores it.
@@ -420,9 +349,6 @@ module Samagotchi
     # or model list this client gets through clears the failures: a server
     # that just answered is not the down or hung one the window remembered.
     def server_props(model: nil)
-      path = @transport.props_path
-      return nil unless path
-
       key = model.to_s
       @props_mutex.synchronize do
         return @props_cache[key] if @props_cache.key?(key)
@@ -431,7 +357,7 @@ module Samagotchi
         return failed if failed && monotonic_now - failed_at < PROPS_FAILURE_TTL
       end
 
-      props = probe_props(path, key)
+      props = probe_props(PROPS_PATH, key)
       @props_mutex.synchronize do
         case props.status
         when :cancelled then nil
@@ -451,10 +377,10 @@ module Samagotchi
     end
 
     # The context window (tokens) the running server was started with, or nil
-    # when the transport reports none or the probe fails (see #server_props).
+    # when the server reports none or the probe fails (see #server_props).
     def context_window(model: nil)
       props = server_props(model: model)
-      props&.answered? ? @transport.context_window_from(props.body) : nil
+      props&.answered? ? Client.context_window_from(props.body) : nil
     rescue StandardError
       nil
     end
@@ -505,28 +431,8 @@ module Samagotchi
       nil
     end
 
-    def resolve_transport(transport)
-      value = (transport || Samagotchi::Config.get("server.transport")).to_s.strip.downcase.to_sym
-      VALID_TRANSPORTS.include?(value) ? value : DEFAULT_TRANSPORT
-    end
-
-    # Build the wire-format strategy for a resolved transport name. oMLX gets
-    # a resolver that maps the short selector to the exact /v1/models id (see
-    # #resolve_omlx_model); mlx gets a resolver that always returns nil so the
-    # `model` field is omitted; llama.cpp uses the strategy's default (forward
-    # the selector verbatim).
-    def build_transport(name)
-      resolver = case name
-                 when :omlx
-                   ->(model) { resolve_omlx_model(model) }
-                 when :mlx
-                   ->(_model) {}
-                 end
-      Transport.new(name, model_resolver: resolver)
-    end
-
     def completion_uri
-      URI("#{@scheme}://#{@host}:#{@port}#{@transport.completion_path}")
+      URI("#{@scheme}://#{@host}:#{@port}#{COMPLETION_PATH}")
     end
 
     def completion_payload(prompt, stop:, n_predict:, model:, sampling: {}, slot: nil, cache_prompt: true)
@@ -534,16 +440,14 @@ module Samagotchi
       # A non-positive cap is dropped, which leaves the length to the server
       # (unbounded): 0 here never means "only process the prompt". The
       # turn-end warm-up (#warm_up) sends its own payload for that reason.
-      payload[@transport.token_limit_key] = n_predict if n_predict && n_predict.to_i.positive?
-      model_name = @transport.model_for_payload(model)
+      payload[:n_predict] = n_predict if n_predict && n_predict.to_i.positive?
+      model_name = Client.model_for_payload(model)
       payload[:model] = model_name if model_name
-      if @transport.native?
-        # llama.cpp's default today, sent anyway: chi's next turn relies on it.
-        # false only for the retry of a malformed generation (KernelLoop),
-        # which a poisoned cache must not produce again.
-        payload[:cache_prompt] = cache_prompt != false
-        payload[:id_slot] = slot if slot.is_a?(Integer)
-      end
+      # llama.cpp's default today, sent anyway: chi's next turn relies on it.
+      # false only for the retry of a malformed generation (KernelLoop),
+      # which a poisoned cache must not produce again.
+      payload[:cache_prompt] = cache_prompt != false
+      payload[:id_slot] = slot if slot.is_a?(Integer)
       sendable_sampling(sampling).merge(payload)
     end
 
@@ -553,48 +457,8 @@ module Samagotchi
       (sampling || {}).reject { |key, value| value.nil? || ConfigFile::SAMPLING_RESERVED_KEYS.include?(key.to_s) }
     end
 
-    # Resolve a user-facing SAMAGOTCHI_DEFAULT_MODEL selector to the exact id oMLX
-    # expects in the request body (an id from its `/v1/models` list).
-    #
-    # Resolution order: exact (case-insensitive) match first, then the first
-    # substring match, else the selector passes through unchanged so oMLX returns
-    # its own 404 listing the available models. An empty selector yields nil (no
-    # model field). The id list is loaded once per client and memoized, but
-    # resolution runs on every completion so a runtime model switch re-resolves.
-    def resolve_omlx_model(raw)
-      value = raw.to_s.strip
-      return nil if value.empty?
-
-      ids = fetch_omlx_model_ids
-      return value if ids.empty?
-
-      ids.find { |id| id.casecmp?(value) } ||
-        ids.select { |id| id.downcase.include?(value.downcase) }.first ||
-        value
-    end
-
-    # Load and memoize the list of model ids from oMLX's `/v1/models`.
-    #
-    # Only memoize on success: a failed `list_models` must leave the cache unset
-    # so the next completion retries (a transient blip shouldn't disable
-    # resolution for the whole session). On failure we return [] so an unknown
-    # selector still passes through raw, letting oMLX return its own 400/404
-    # (server decides), as documented in docs/configuration.md.
-    def fetch_omlx_model_ids
-      return @omlx_model_ids if defined?(@omlx_model_ids)
-
-      begin
-        ids = list_models.map { |m| m.is_a?(Hash) ? m["id"] : m }
-      rescue StandardError
-        return []
-      end
-
-      @omlx_model_ids = ids
-      ids
-    end
-
     # Returns [content, payload] for a streamed SSE line, or nil to skip
-    # (blank lines, non-data lines, and the mlx/oMLX `[DONE]` sentinel).
+    # (blank lines, non-data lines, and a `[DONE]` sentinel).
     # Raises the ProviderError of a server's error event.
     def parse_stream_line(line)
       error = LLM::HTTP.sse_error(line, host: @label)
@@ -609,8 +473,7 @@ module Samagotchi
       rescue JSON::ParserError => e
         raise LLM::ProtocolError.new("#{@label}: malformed stream chunk: #{e.message[0, 200]}", host: @label)
       end
-      content = @transport.content_from_payload(payload)
-      [content, payload]
+      [payload.fetch("content", ""), payload]
     end
   end
 end

data/lib/samagotchi/config.rb

@@ -84,7 +84,6 @@ module Samagotchi
       # The prompt profile for every model in this process (ModelProfile::NAMES).
       # No config key: per-model and per-host profiles live in models: and hosts:.
       Entry.new(key: "model.profile",            yaml_path: %w[model profile],            type: :enum,   default: nil,              expose: %i[env cli], enum_values: %w[qwen36 gemma4]),
-      Entry.new(key: "server.transport",         yaml_path: %w[server transport],          type: :enum,   default: "llama_cpp",     expose: %i[env config cli], enum_values: %w[llama_cpp mlx omlx], lifecycle: :worker_start),
       Entry.new(key: "server.host",              yaml_path: %w[server host],               type: :string, default: "localhost",     expose: %i[env config cli], lifecycle: :worker_start),
       Entry.new(key: "server.port",              yaml_path: %w[server port],               type: :integer, default: 8080,            expose: %i[env config cli], lifecycle: :worker_start),
       Entry.new(key: "server.open_timeout",      yaml_path: %w[server open_timeout],       type: :integer, default: 10,              expose: %i[env config cli], lifecycle: :worker_start),
@@ -205,7 +204,6 @@ module Samagotchi
       # The policy sentence forget_outputs' description carries (the forget layer); blank: none.
       Entry.new(key: "llm_context.policy",       yaml_path: %w[llm_context policy],       type: :string, default: LLMContextStrategy::DEFAULT_POLICY, expose: %i[env config], lifecycle: :worker_start),
 
-      Entry.new(key: "thinking.turn_preamble",   yaml_path: %w[thinking turn_preamble],   type: :bool,   default: true,             expose: %i[env config cli], lifecycle: :prompt_rebuild),
       # How much models think: off|low|medium|high|default, parsed by Thinking
       # (a :string, since YAML reads an unquoted off as false). The CLI flag
       # is bin/chi's own --thinking; models: and hosts: entries rank below
@@ -312,7 +310,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 auth dialect profile first_token_timeout vision sampling thinking
+      "hosts" => %w[host port url 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
@@ -644,6 +642,7 @@ module Samagotchi
       # nil when +dotted+ is a key the file may hold.
       def key_problem(dotted)
         return nil if known_config_keys.include?(dotted)
+        return "config: #{ConfigFile.removed_transport_problem("'#{dotted}'")}" if dotted == "server.transport"
         if (replaced = REPLACED_KEYS[dotted])
           return "config: unknown key '#{dotted}': replaced by '#{replaced}' (hard, standard or soft; see docs/guardrails.md)"
         end
@@ -669,6 +668,8 @@ module Samagotchi
           next [] unless entry.is_a?(Hash)
 
           (entry.keys.map(&:to_s) - allowed).map do |k|
+            next "config: #{ConfigFile.removed_transport_problem("'hosts.#{name}.transport'")}" if map == "hosts" && k == "transport"
+
             unknown_key_message("#{map}.#{name}.#{k}", k, allowed, prefix: "#{map}.#{name}.")
           end + (map == "hosts" ? host_model_problems(name, entry["models"]) : [])
         end
@@ -887,13 +888,17 @@ module Samagotchi
     end
 
     # Check config.yml once at start (warnings for keys the code doesn't
-    # read) and clear the CLI settings. Nothing is copied into ENV: every
+    # read, and for SAMAGOTCHI_SERVER_TRANSPORT) and clear the CLI settings. Nothing is copied into ENV: every
     # Config.get reads the file again when it changed, so a long-lived
     # process (chi web) and the workers it spawns see edits, and a file
     # value reports origin :file. Returns true if the file existed.
     def load!(env: ENV, path: global_path(env: env))
       existed = File.file?(path)
       raw = read_yaml(env: env, path: path) || {}
+      check_removed_apis!(raw, env: env)
+      unless env[REMOVED_TRANSPORT_ENV].to_s.strip.empty?
+        Log.warn(:config, "config_key", echo: "Warning: #{removed_transport_problem(REMOVED_TRANSPORT_ENV)}")
+      end
       if existed
         Samagotchi::Config.validate_yaml_sections(raw).each { |w| Log.warn(:config, "config_key", echo: "Warning: #{w}") }
       end
@@ -901,6 +906,39 @@ module Samagotchi
       existed
     end
 
+    # Raises RemovedApi for the first api/transport in +data+ (config.yml)
+    # or the environment that names a removed one: config.yml's
+    # hosts.<name>.api, and the removed transport keys (server.transport,
+    # hosts.<name>.transport, SAMAGOTCHI_SERVER_TRANSPORT), which with
+    # another value only warn (#removed_transport_problem). Run once at
+    # start (#load!); a hosts entry read later says the same through
+    # HostConfig.parse and is left out.
+    def check_removed_apis!(data, env: ENV)
+      env_value = env[REMOVED_TRANSPORT_ENV]
+      raise RemovedApi.new(REMOVED_TRANSPORT_ENV, env_value.to_s.strip) if removed_api?(env_value)
+
+      server = data["server"] if data.is_a?(Hash)
+      value = server["transport"] if server.is_a?(Hash)
+      raise RemovedApi.new("config.yml server.transport", value) if removed_api?(value)
+
+      hosts = data[HOSTS_KEY] if data.is_a?(Hash)
+      return unless hosts.is_a?(Hash)
+
+      hosts.each do |name, cfg|
+        next unless cfg.is_a?(Hash)
+
+        %w[api transport].each do |key|
+          value = cfg[key]
+          raise RemovedApi.new("config.yml hosts.#{name}.#{key}", value) if removed_api?(value)
+        end
+      end
+    end
+
+    # Whether +value+ (as written) names a removed api/transport.
+    def removed_api?(value)
+      REMOVED_APIS.include?(value.to_s.strip.downcase)
+    end
+
     def config_dir(env: ENV)
       File.join(Paths.config_home(env: env), CONFIG_DIR)
     end
@@ -909,18 +947,42 @@ module Samagotchi
       File.join(config_dir(env: env), CONFIG_FILE)
     end
 
+    # A key chi no longer reads, set to anything but a removed api (that is
+    # a RemovedApi): config.yml server.transport, a hosts entry's
+    # transport: or the environment variable. llama.cpp is the one
+    # raw-prompt transport, so the key changes nothing: a warning, the
+    # config still loads. +where+ names it as the reader shows it.
+    def removed_transport_problem(where)
+      "#{where} was removed: llama.cpp is chi's only raw-prompt transport " \
+        "(a hosts entry without api: is api: llama_cpp); remove it"
+    end
+
+    REMOVED_TRANSPORT_ENV = "SAMAGOTCHI_SERVER_TRANSPORT"
     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 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
+    # api/transport values chi no longer has: its own mlx_lm.server and
+    # oMLX transports, gone for their OpenAI chat endpoint (api: openai).
+    REMOVED_APIS = %w[mlx omlx].freeze
+
+    # A config naming a removed api/transport (REMOVED_APIS). The message
+    # is the one line the user sees: where, the value, what to write.
+    class RemovedApi < StandardError
+      # @param where [String] e.g. "config.yml hosts.mac.api"
+      # @param value [String] the removed value as written
+      def initialize(where, value)
+        super("#{where}: #{value} was removed; for mlx_lm.server or oMLX use url: http://HOST:PORT/v1, api: openai in a hosts: entry")
+      end
+    end
+    # How chi talks to a host: llama_cpp (the raw-prompt loop over
+    # llama.cpp's own API, also what a hosts entry without api: talks), or a
+    # chat api the chat loop talks (LLM::Adapters): openai (Chat Completions
+    # against <host>/v1) or anthropic (Messages).
+    VALID_APIS_FOR_CONFIG = %w[llama_cpp 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: by lowercased name; an entry that is disabled or
     # invalid (warned) is left out. No entry left: "default", from
-    # server.host/port/transport.
+    # server.host/port.
     # @return [Hash{String => HostConfig}]
     def hosts_config(env: ENV, path: global_path(env: env))
       data = read_yaml(env: env, path: path)
@@ -941,17 +1003,14 @@ module Samagotchi
       {}
     end
 
-    # The host chi uses when hosts: names none: server.host/port/transport.
+    # The host chi uses when hosts: names none: server.host/port.
     def default_host_config(data, env)
       opts = { file_data: data, env: env, cli_overrides: Samagotchi::Config.cli_overrides }
       host = Samagotchi::Config.resolve("server.host", **opts).to_s.strip
       host = "localhost" if host.empty?
       port = Samagotchi::Config.resolve("server.port", **opts).to_i
       port = 8080 if port <= 0 || port > 65_535
-      transport = Samagotchi::Config.resolve_with_origin("server.transport", **opts).then do |value, origin|
-        origin == :default ? nil : value.to_sym
-      end
-      HostConfig.new(name: "default", host: host, port: port, transport: transport)
+      HostConfig.new(name: "default", host: host, port: port)
     end
     private_class_method :default_host_config
 

data/lib/samagotchi/engine.rb

@@ -1627,8 +1627,8 @@ module Samagotchi
     # prompt prefix, and the server's KV cache for it, stay stable.
     # @param model [EffectiveModel, nil]
     # @return [String]
-    # The native prompt depends on the thinking level too (Gemma's token,
-    # Qwen's turn preamble): a level change builds it again. A build that
+    # The native prompt depends on the thinking level too (Gemma's token):
+    # a level change builds it again. A build that
     # misses the cache names the model and the level through its own
     # lambdas (#model_identity, #turn_thinking), which resolve again.
     def system_prompt(model = nil)
@@ -1644,8 +1644,8 @@ module Samagotchi
     end
 
     # The base prompt (specs, plugins' declarations).
-    def assist_system_prompt(chat: false, thinking: nil)
-      @prompt_builder.base(chat: chat, thinking: thinking)
+    def assist_system_prompt(chat: false)
+      @prompt_builder.base(chat: chat)
     end
 
     # The --memory names activated while building the prompt; the TerminalUI
@@ -2048,10 +2048,10 @@ module Samagotchi
 
     # Never a paid or remote host (cache.warmup auto means local only), nor
     # the chat loop (Splash keeps its own cache; llama.cpp's chat path is
-    # not measured), nor a non-llama.cpp transport.
+    # not measured), nor a client that can't warm up (a spec's stub).
     def warmup_target?(model, client)
       return false if model.chat? || model.entry.remote?
-      return false unless client.respond_to?(:warm_up) && client.respond_to?(:transport) && client.transport.native?
+      return false unless client.respond_to?(:warm_up)
 
       PromptWarmup.enabled?
     end
@@ -2095,7 +2095,7 @@ module Samagotchi
       # could change what a resolve gives (the hooks ran before).
       model = effective_model
       sync_kernel_client!(model)
-      # Route model name as bare (without host prefix) to the transport;
+      # Route model name as bare (without host prefix) to the server;
       # host selection already done via active client.
       bare_for_backend = bare_model_name(model.name)
       # The turn's settings, set once here. The chat loop dispatches tools