samagotchi 0.94.0 → 0.95.0

data/lib/samagotchi/bundles/system/config_modification_protocol.md

@@ -18,7 +18,7 @@ Single registry `Samagotchi::Config` (`Config::ENTRIES` in `lib/samagotchi/confi
 
 Sections forbid `_`/`-` (`SECTION_RE` `/\A[a-z0-9]+\z/`); leaves keep `snake_case` in YAML (`base_url`) and become kebab in CLI (`base-url`) via registry derivation — no generic string split, registry lookup avoids flat vs nested collision.
 
-**Universal entries** (`expose: [:env,:config,:cli]`): `default.model`, `server.host/port/transport/open_timeout/read_timeout`, `server.first_token_timeout` (env and config only), `recap.model/base_url/host_ref/inactivity/timeout/min_user_turns/sentences`, `session.retention_days/max_count/keep_status/sweep_interval_hours/idle_exit_minutes`, `session.shared/keep_empty/max_children` (env and config only), `log.file/disable`, `status.line`, `context.status/window_tokens/chars_per_token/status_thresholds`, `memory.index_warn_tokens`, `thinking.turn_preamble`, `default.max_tokens`, `max_tool_output_chars`, `retry.max/base_delay/max_delay`, `read.*`, `execute.*`, `web.port/host`, `no_interrupt`, `no_default_input` etc. (`Config::ENTRIES`; `expose` says which of env/config/cli each takes). Precedence is `CLI > ENV > file > default`.
+**Universal entries** (`expose: [:env,:config,:cli]`): `default.model`, `server.host/port/open_timeout/read_timeout`, `server.first_token_timeout` (env and config only), `recap.model/base_url/host_ref/inactivity/timeout/min_user_turns/sentences`, `session.retention_days/max_count/keep_status/sweep_interval_hours/idle_exit_minutes`, `session.shared/keep_empty/max_children` (env and config only), `log.file/disable`, `status.line`, `context.status/window_tokens/chars_per_token/status_thresholds`, `memory.index_warn_tokens`, `default.max_tokens`, `max_tool_output_chars`, `retry.max/base_delay/max_delay`, `read.*`, `execute.*`, `web.port/host`, `no_interrupt`, `no_default_input` etc. (`Config::ENTRIES`; `expose` says which of env/config/cli each takes). Precedence is `CLI > ENV > file > default`.
 
 Example `config.yml` (new nested form, preferred):
 
@@ -29,7 +29,6 @@ default:
 server:
   host: localhost
   port: 8080
-  transport: llama_cpp  # llama_cpp|mlx|omlx
   first_token_timeout: 120  # seconds a request may wait for its first token; 0 = off; unset: 120 for remote hosts, none for local
 recap:
   host_ref: small-box   # a name under hosts:, or base_url: http://...
@@ -57,8 +56,8 @@ Only the nested form is read. An env name used as a top-level key (`SAMAGOTCHI_D
 **Excluded maps** (YAML-only, not part of the flat registry; skipped by scalar loader):
 
 - `model_aliases:` map of alias → model id (`ModelRef.parse`, through `HostRegistry#resolve`). Keys lowercased on write (`ConfigFile.write_model_alias!`). Values may be bare `model` or qualified `host:model` (hybrid; only `:` names a host, `org/model` is an id). Aliases apply once: never point an alias at another alias.
-- `hosts:` map of `name → {host, port | url, transport, api, api_key_env, auth, dialect, profile, first_token_timeout, vision, sampling, thinking, enabled, models}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `auth:` (`bearer|x-api-key`) is the header the key goes in (default `x-api-key` on `api: anthropic`, Bearer elsewhere); `dialect:` (`fireworks`, or `standard` for the default; `api: anthropic` only) adjusts the Messages wire for that provider (Bearer by default, no thinking `display`, no `cache_control`, `x-session-affinity`; `LLM::Dialect`, docs/configuration.md "Anthropic Messages hosts"); `transport` overrides `server.transport`; `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; `models:` (a map of model ids, or a plain list) declares ids the host serves whatever its `/v1/models` lists: no "doesn't list" warning, and a bare id routes there as if listed (`HostModel`); an entry may hold `price: {input, output, cache_read?, cache_write?}` in USD per 1M tokens (`ModelPrice`; an unset cache rate is the input rate), which estimates a cost the provider doesn't report or reports as 0 (`cost_estimate`, shown as `~$`), and `served: [ids] | any`, the models a gateway may answer that id with (no served-model warning for them); model settings stay in the root `models:`; a worker reads `hosts:` from the file as it starts (no environment variable sets hosts).
-- `models:` map of model id or alias → `{profile, vision, sampling, thinking, reasoning_history}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: the session's own level (`/thinking LEVEL`, saved in the session; `chi --thinking` on a session run, `chi send --new --thinking`) > `chi web --thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `reasoning_history:` (here or on a host) is `drop|turn|all`, which of its reasoning a chat host's model gets back. Precedence: the session's own level (`/reasoning-history LEVEL`, saved in the session) > `SAMAGOTCHI_REASONING_HISTORY` > `models:` > `hosts.<name>.reasoning_history` > `turn`; `docs/configuration.md` "Reasoning history". `/thinking` and `/reasoning-history` ask before a change that restarts the prompt cache; `--yes` applies it (`chi send` commands apply directly). `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name on mlx, which has no template to read).
+- `hosts:` map of `name → {host, port | url, api, api_key_env, auth, dialect, profile, first_token_timeout, vision, sampling, thinking, enabled, models}` (`ConfigFile.hosts_config`, `host_registry.rb` `HostEntry`). Names lowercased; `url:` (http/https, optional path) replaces host/port, never both; `api_key_env:` names the env var holding the API key (never write a key into config.yml); `auth:` (`bearer|x-api-key`) is the header the key goes in (default `x-api-key` on `api: anthropic`, Bearer elsewhere); `dialect:` (`fireworks`, or `standard` for the default; `api: anthropic` only) adjusts the Messages wire for that provider (Bearer by default, no thinking `display`, no `cache_control`, `x-session-affinity`; `LLM::Dialect`, docs/configuration.md "Anthropic Messages hosts"); `first_token_timeout` (seconds, `0` = off; a negative or non-number warns and is ignored) overrides `server.first_token_timeout` for that host; `models:` (a map of model ids, or a plain list) declares ids the host serves whatever its `/v1/models` lists: no "doesn't list" warning, and a bare id routes there as if listed (`HostModel`); an entry may hold `price: {input, output, cache_read?, cache_write?}` in USD per 1M tokens (`ModelPrice`; an unset cache rate is the input rate), which estimates a cost the provider doesn't report or reports as 0 (`cost_estimate`, shown as `~$`), and `served: [ids] | any`, the models a gateway may answer that id with (no served-model warning for them); model settings stay in the root `models:`; a worker reads `hosts:` from the file as it starts (no environment variable sets hosts).
+- `models:` map of model id or alias → `{profile, vision, sampling, thinking, reasoning_history}` (`ConfigFile.model_settings`). `thinking:` (here, on a host, or `thinking.level` for every model) is `off|low|medium|high|default` (`Thinking`; unquoted `off` works, `on` is not a level; `default` = send nothing). Precedence: the session's own level (`/thinking LEVEL`, saved in the session; `chi --thinking` on a session run, `chi send --new --thinking`) > `chi web --thinking`/`SAMAGOTCHI_THINKING_LEVEL` > `models:` > `hosts.<name>.thinking` > `thinking.level` in config.yml > `default`. A `sampling:` key wins over the fields a level sends (`null` drops one); `docs/configuration.md` "Thinking". `reasoning_history:` (here or on a host) is `drop|turn|all`, which of its reasoning a chat host's model gets back. Precedence: the session's own level (`/reasoning-history LEVEL`, saved in the session) > `SAMAGOTCHI_REASONING_HISTORY` > `models:` > `hosts.<name>.reasoning_history` > `turn`; `docs/configuration.md` "Reasoning history". `/thinking` and `/reasoning-history` ask before a change that restarts the prompt cache; `--yes` applies it (`chi send` commands apply directly). `sampling:` (here or on a host) is a map of request fields passed to the provider as written (`temperature`, `top_p`, `presence_penalty`, `repeat_penalty`, …; a model's fields win over its host's per field; `null` = don't send; chi's own fields like `max_tokens`/`stream` are refused with a warning; `docs/configuration.md` "Sampling"). Keys match case-insensitively. `profile` (here or on a host) is `qwen36|gemma4`: the raw prompt format for native hosts. Precedence: `--profile`/`SAMAGOTCHI_MODEL_PROFILE` > `models:` > `hosts.<name>.profile` > the llama.cpp server's chat template > the name (`qwen`/`gemma`) > `qwen36` (`ModelProfile.resolve`). Set one when a model's name hides its family (e.g. a Qwen fine-tune under another name whose server publishes no template).
 - `hooks:` map of `hooks_dir` + per-event lists `{path, on_error}` (`Hooks::Loader.load`). `hooks_dir` may start with `~`.
 - `guardrails:` tool-call rules (`docs/guardrails.md`; read in `Engine#guardrail_rules`, parsed by `Guardrails::Rules.parse`): `enabled` (bool, default true; `false` drops rules and hooks' asks, a deny still applies; config.yml only, like every `guardrails` setting: no env variable), `parent_answers` (`soft`, the default: a parent agent's `chi answer` may deny, answer, Continue and give "Allow once"; `standard`: no allow; `hard`: deny, Stop and plain answers only; never a wider scope; replaces `parent_approvals` and `turn.parent_continue`; a convention for an honest parent, not a security boundary, and the user's choice: set it only when the user asks), `rules:` (list), `disable:` (a rule id or a list of them, `id` or `bundle:id`, switching off a bundle's or config rule without editing it), `small_models` (`auto`, the default: small = 32B or less read from the name; a glob or list of globs; `[]` for none). A rule takes only `id`, `tool`, `command`, `path`, `git`, `models`, `verdict`, `reason`, `scopes`: `id` required; at least one of `tool` (a name, `shell` = execute + task_create, a `File.fnmatch` glob like `"mcp_*"`, or a list), `command` (a Ruby regex on the shell command), `path` (a glob, or `outside_repo`: outside the session's repo, tmp folders and memory files excepted), `git` (only `outside_repo`: a shell call runs commit/add/reset/… in another checkout); `models` (optional: `small`, a model-name glob, or a list; without it the rule is for every model); `verdict` `ask|deny`; `scopes` (for `ask`) a subset of `once, session, repo, rule`. **Any parse error (an unknown key, a bad regex, no verdict) makes chi deny every tool call** until fixed, so validate with `YAML.safe_load` and keep the list shape. Rules are read again on the next tool call after config.yml or a bundle's rules change: no restart needed. Installed bundles' rule files (`chi bundle install guardrails`) add to them; `/guardrails` lists what loaded.
 
@@ -132,8 +131,8 @@ A key never goes into config.yml: `api_key_env: VAR` names it. chi reads `VAR` f
 ## Validations
 
 - **Model name** (`default.model` / `SAMAGOTCHI_DEFAULT_MODEL`): `ModelProfile.required_model_name` — non-empty string, otherwise harness fails fast at startup. Via `Config.get("default.model")`.
-- **Host api** (`hosts.<name>.api`): `llama_cpp|mlx|omlx` (raw-prompt loop; also the transport), `openai` (chat loop at `http://HOST:PORT/v1`) or `anthropic` (chat loop over the Messages API at `{url}/v1/messages`; without `url:`/`host:` it is `https://api.anthropic.com`). Absent: raw-prompt loop. It replaces the removed `backend` setting.
-- **Transport** (`server.transport`): enum `llama_cpp|mlx|omlx`.
+- **Host api** (`hosts.<name>.api`): `llama_cpp` (raw-prompt loop over llama.cpp's own API), `openai` (chat loop at `http://HOST:PORT/v1`) or `anthropic` (chat loop over the Messages API at `{url}/v1/messages`; without `url:`/`host:` it is `https://api.anthropic.com`). Absent: raw-prompt loop. It replaces the removed `backend` setting.
+- **No transport key**: `server.transport`, `hosts.<name>.transport` and `SAMAGOTCHI_SERVER_TRANSPORT` were removed (llama.cpp is the only raw-prompt server; never write them). Set to `mlx`/`omlx` (or `api: mlx`/`omlx`), chi stops at start with one line (`ConfigFile::RemovedApi`): mlx_lm.server and oMLX are `url: http://HOST:PORT/v1, api: openai` hosts. Any other value warns at start (`ConfigFile.removed_transport_problem`); remove the key.
 - **Profile** (`models.<id>.profile`, `hosts.<name>.profile`, `SAMAGOTCHI_MODEL_PROFILE`): enum `qwen36|gemma4`; an unknown one warns and is ignored.
 - **Alias name** (`write_model_alias!`):
   - required, non-empty, no whitespace, not starting with `-`, no `/`, must match `/\A[a-z0-9][a-z0-9._-]*\z/i`
@@ -141,7 +140,7 @@ A key never goes into config.yml: `api_key_env: VAR` names it. chi reads `VAR` f
   - must not point to itself (case-insensitive)
   - keys are normalized to downcase on write — `Qwen` and `qwen` collide
 - **Alias target**: non-empty string (model id).
-- **Hosts**: each entry needs `host` (or `url:`, an http(s) URL with an optional path, replacing `host`/`port`; never both), `port` 1-65535 (default 8080), `enabled: false` skips the entry, `transport` and `api` optional (a raw `api` must match `transport`), name must match `/\A[a-z0-9][a-z0-9._-]*\z/i`.
+- **Hosts**: each entry needs `host` (or `url:`, an http(s) URL with an optional path, replacing `host`/`port`; never both), `port` 1-65535 (default 8080), `enabled: false` skips the entry, `api` optional (`llama_cpp`, `openai`, `anthropic`), name must match `/\A[a-z0-9][a-z0-9._-]*\z/i`.
 - **Hooks**: each entry must have `path` (relative to `hooks_dir`), `on_error` is `skip` (default) or `log`; `required: true` on a `before_tool_call` hook denies the call when the hook raises. Class name must match file basename snake→Pascal.
 - **Scalars via registry**: `Config.coerce` validates `String/Numeric/true/false` per `type: :string/:integer/:float/:bool/:enum`; invalid values warn and fall back to entry `default`.
 - **Keys**: `validate_yaml_sections` flags unknown keys (with a suggestion), a registry section that isn't a mapping, and env/CLI-only keys (`model.profile`).

data/lib/samagotchi/bundles/system/manifest.yml

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.94.0
+version: 0.95.0
 scope: system
 description: Default system memories — identity, self map, config modification protocol, memory guide and the delegated-session rules
 files:
   identity.md: sha256:29c2f7df9f6c5acbc5ec17000a4490741e55e426af15ca0d81c8706edd9bd027
-  self_map.md: sha256:da591d30211488eb7cff36604502b78167b0d6b64c1fbb827eca16b8703a63e7
-  config_modification_protocol.md: sha256:f2551c71a21cc42e8b888e4b9b41f4b0909224e5393731905c1f786c704bad14
+  self_map.md: sha256:df3f8da539a9f5812f79e089c2c8b9894da6124a89654f292160046a6bb060da
+  config_modification_protocol.md: sha256:ff4efccf2bdde453fc4e6741df8c18f78da78e353f6b1a5a64d0e7a631aea258
   memory_guide.md: sha256:c48eea744db69e4f3e9bb415e9a03a8c78bbcaa1205ad3b1fb157a079f92d22e
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

data/lib/samagotchi/bundles/system/self_map.md

@@ -68,7 +68,7 @@
 
 ## Where things live (relative to the source dir)
 - `docs/`: `cli.md` (flags, subcommands, REPL commands), `configuration.md` (config.yml keys,
-  hosts, transports), `hooks.md` (hook events table), `plugins.md` (plugin API, btw/mcp bundles),
+  hosts, the server api), `hooks.md` (hook events table), `plugins.md` (plugin API, btw/mcp bundles),
   `guardrails.md`, `memory.md`, `sessions.md`. `README.md` is only the quickstart.
 - `lib/samagotchi/tools/<tool>.rb`: each tool's real limits and defaults (e.g. `execute.rb`,
   `output_guardrails.rb`). Tool descriptions are summaries, not the spec.

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