samagotchi 0.94.0 → 0.95.0

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

data/lib/samagotchi/host_config.rb

@@ -13,13 +13,13 @@ module Samagotchi
   # one).
   #
   # 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; auth: the header the API key goes in
+  # url: when given); url: the configured url, nil when host/port; api: a
+  # symbol, nil when unset (llama_cpp's raw-prompt loop); 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,
+  HostConfig = Data.define(:name, :host, :port, :scheme, :url, :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
@@ -79,10 +79,10 @@ module Samagotchi
         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)
+      kind = parse_api(name, value.call(:api), value.call(:transport)) or return nil
+      location = parse_location(name, value, api: kind[:api]) or return nil
+      fields[:dialect] = LLM::Dialect.parse(value.call(:dialect), where, api: kind[:api])
+      new(name: name.downcase, **location, **kind, **fields)
     rescue StandardError => e
       # One entry that trips a reader is dropped on its own, and said so;
       # the other hosts stay (the worker's copy too).
@@ -143,29 +143,22 @@ module Samagotchi
     end
     private_class_method :parse_location
 
-    # transport: and api: as symbols; a raw-prompt api is also the
-    # transport. nil (warned) when unknown or contradicting each other.
-    def self.parse_kinds(name, transport, api)
-      transport = transport.to_s.strip.downcase
-      if transport.empty?
-        transport = nil
-      elsif !ConfigFile::VALID_TRANSPORTS_FOR_CONFIG.include?(transport)
-        return invalid(name, "unknown transport '#{transport}'")
+    # { api: } (a symbol, nil when not given), or nil (warned) when the api
+    # is unknown. A removed api (RemovedApi) in api: or in the old
+    # transport: key leaves the entry out with its line; any other
+    # transport: is only warned about at start
+    # (ConfigFile.removed_transport_problem).
+    def self.parse_api(name, api, transport)
+      %w[api transport].zip([api, transport]).each do |key, written|
+        return invalid(name, ConfigFile::RemovedApi.new("hosts.#{name}.#{key}", written.to_s.strip).message) if ConfigFile.removed_api?(written)
       end
       api = api.to_s.strip.downcase
-      if api.empty?
-        api = nil
-      elsif !ConfigFile::VALID_APIS_FOR_CONFIG.include?(api)
-        return invalid(name, "unknown api '#{api}'")
-      elsif ConfigFile::VALID_TRANSPORTS_FOR_CONFIG.include?(api)
-        # A raw-prompt api is the transport; a different transport contradicts it.
-        return invalid(name, "api '#{api}' conflicts with transport '#{transport}'") if transport && transport != api
-
-        transport = api
-      end
-      { transport: transport&.to_sym, api: api&.to_sym }
+      return { api: nil } if api.empty?
+      return invalid(name, "unknown api '#{api}'") unless ConfigFile::VALID_APIS_FOR_CONFIG.include?(api)
+
+      { api: api.to_sym }
     end
-    private_class_method :parse_kinds
+    private_class_method :parse_api
 
     def self.invalid(name, reason)
       ConfigFile.warn_once "Warning: ignoring hosts entry '#{name}': #{reason}"

data/lib/samagotchi/host_registry.rb

@@ -10,7 +10,7 @@ require_relative "llm/adapters"
 require_relative "llm/dialect"
 
 module Samagotchi
-  # HostRegistry manages multiple model hosts (llama.cpp / mlx / oMLX) and
+  # HostRegistry manages multiple model hosts (llama.cpp, OpenAI-compatible, Anthropic) and
   # provides lazy model discovery aggregation.
   #
   # - Hosts are defined in config.yml `hosts:` section or synthesized from
@@ -46,7 +46,7 @@ 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, :auth, :dialect,
+    HostEntry = Struct.new(:name, :host, :port, :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
@@ -126,7 +126,7 @@ module Samagotchi
         # Every HostConfig field is a HostEntry member (a new one must be added there too).
         fields = cfg.to_h.merge(name: key.to_s.downcase, port: cfg.port.to_i, api: cfg.api&.to_sym, models: cfg.models || {})
         entry = HostEntry.new(**fields)
-        entry.client = Client.new(host: cfg.host, port: cfg.port, transport: cfg.transport, scheme: cfg.scheme,
+        entry.client = Client.new(host: cfg.host, port: cfg.port, scheme: cfg.scheme,
                                   first_token_timeout: entry.first_token_limit, name: entry.name,
                                   api_key_env: entry.api_key_env, auth: entry.auth_scheme, env: env)
         @entries[entry.name] = entry
@@ -137,7 +137,7 @@ module Samagotchi
         host = "localhost" if host.empty?
         port = Config.get("server.port").to_i
         port = 8080 if port <= 0
-        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, transport: nil, models: {},
+        @entries["default"] = HostEntry.new(name: "default", host: host, port: port, models: {},
                                             client: Client.new(host: host, port: port, name: "default"))
       end
       @mutex = Mutex.new
@@ -341,7 +341,7 @@ module Samagotchi
     end
 
     # List models on all hosts in parallel. On error per-host, skip with error entry (no failover).
-    # Returns { host_name => { host:, port:, transport:, models: [LLM::ModelInfo], error: nil|String } }
+    # Returns { host_name => { host:, port:, models: [LLM::ModelInfo], error: nil|String } }
     # Also populates the model index. Unless forced, a host's list is reused
     # for its TTL (60s; 10 minutes for a remote host).
     #
@@ -361,12 +361,12 @@ module Samagotchi
         Thread.new do
           begin
             models = list_models_for(entry)
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: models, error: nil }
+            data = { host: entry.host, port: entry.port, models: models, error: nil }
             @mutex.synchronize { @host_lists[name] = { data: data, at: @clock.call } }
             save_model_list(name, models)
           rescue StandardError => e
             Log.warn(:model, "list_failed", host: name, error: e.class.name, msg: e.message.to_s[0, 500])
-            data = { host: entry.host, port: entry.port, transport: entry.transport, models: [], error: list_error(e) }
+            data = { host: entry.host, port: entry.port, models: [], error: list_error(e) }
           end
           results_mutex.synchronize { results[name] = data }
         end
@@ -380,7 +380,7 @@ module Samagotchi
           @entries.each_with_object({}) do |(name, entry), acc|
             acc[name] = results.fetch(name) do
               partial = true
-              { host: entry.host, port: entry.port, transport: entry.transport, models: [],
+              { host: entry.host, port: entry.port, models: [],
                 error: "no answer in #{wait == wait.to_i ? wait.to_i : wait} s" }
             end
           end

data/lib/samagotchi/kernel_loop.rb

@@ -193,7 +193,7 @@ module Samagotchi
     attr_accessor :llm_context_turn
     # @return [Integer, nil] the llama.cpp slot (`id_slot`) the last
     #   request of the last run streamed from; nil when the server named
-    #   none (other transports) or no request was made
+    #   none or no request was made
     attr_reader :last_slot
 
     # Run the conversation loop and return the final model response plus
@@ -294,8 +294,8 @@ module Samagotchi
     Request = Struct.new(:prompt, :images, :image_tokens, :window, :prefill, keyword_init: true)
     # One generation: the response (nil when cut), the cut's detail, this
     # generation's own server counts, the model the server named, the
-    # thinking it streamed, and why it stopped (the transport's finish
-    # reason, Client::Transport#finish_reason_from; nil when not named),
+    # thinking it streamed, and why it stopped (llama.cpp's finish
+    # reason, Client.finish_reason_from; nil when not named),
     # and its prompt-cache counts (the largest seen: they come cumulative),
     # and where its visible text starts in the turn's buffer.
     Generation = Struct.new(:response, :cut, :usage, :served_model, :streamed_thinking, :finish_reason, :cache,
@@ -312,15 +312,32 @@ module Samagotchi
         empty_retry: EmptyAnswerRetry.new, empty_steps: [], tool_activity: [], buffer: +"", streamed_thinking: +"",
         qwen_attempts: 0, qwen_partial: nil,
         # Qwen with thinking off: an empty thought after the cue, so the model
-        # answers at once. Kept in the turn's model messages, so each tool-loop
-        # prompt starts with what the server already has cached.
-        prefill: Thinking.native(@turn_settings.thinking || Thinking::DEFAULT, @profile).prefill,
+        # answers at once; on, an open one where the server's template has
+        # it. Kept in the turn's model messages, so each tool-loop prompt
+        # starts with what the server already has cached.
+        prefill: native_prefill(@turn_settings.thinking || Thinking::DEFAULT),
         pending_tool_calls: false, model_name: @turn_settings.model_name, pending_input: pending_input,
         on_stream_event: on_stream_event, cancel_controller: cancel_controller, cap: cap,
         emit: emit
       )
     end
 
+    # The text after the cue for +level+ (Thinking.native), set once per
+    # turn. Only qwen36 with thinking on asks the server's template whether
+    # it opens a thought: the /props answer the profile and the window
+    # probes cached (no template, as a router's own /props or a failed
+    # probe: no open thought, the prompt as before).
+    def native_prefill(level)
+      opens = @profile&.name == "qwen36" && level != :off && Thinking.opens_thought?(model_props)
+      Thinking.native(level, @profile, opens_thought: opens).prefill
+    end
+
+    def model_props
+      @client.respond_to?(:server_props) ? @client.server_props(model: @turn_settings.model_name) : nil
+    rescue StandardError
+      nil
+    end
+
     # One iteration. Returns :next, :answer (the turn ends), or the turn's
     # result (it ended cancelled).
     def iterate(turn)
@@ -336,13 +353,28 @@ module Samagotchi
       # Profile-specific parse (incl. Qwen unterminated-block recovery); the
       # returned fragment (non-nil only for Qwen) is fed back on the next
       # iteration if the model opened a tool-call block it did not close.
-      calls, turn.qwen_partial = parser.parse_with_recovery(generation.response, turn.qwen_partial)
+      calls, turn.qwen_partial = parser.parse_with_recovery(callable_text(request, generation), turn.qwen_partial)
       calls = calls.map { |call| PromptLiteralGuard.restore_call(call, profile: @profile) }
       return after_text(turn, request, generation) if calls.empty?
 
       dispatch_calls(turn, calls)
     end
 
+    # The reply's text the tool-call parse reads: with a closed thought
+    # (Qwen's </think>, the prefill's open thought included), what is left
+    # without its thought blocks, so a call the model only thought about
+    # neither runs nor asks for a recovery (the UIs show it as thinking).
+    # A thought never closed stays: a model that writes its call there
+    # still has it run. The model message keeps the whole reply.
+    def callable_text(request, generation)
+      response = generation.response.to_s
+      close = @profile.thought_close
+      full = request.prefill + response
+      return response unless close && full.include?(close)
+
+      strip_thought_blocks(full)
+    end
+
     # The prompt for this iteration, after the context check: a rise into a
     # bucket that asks the model for a change puts its line on the tail
     # (the prompt cache keeps its prefix), and the prompt is formatted again
@@ -427,6 +459,10 @@ module Samagotchi
         # thinking) leaves the splitter inside that block, so rebuilding it
         # keeps the restarted stream's prose in the right lane.
         stream_splitter = ThoughtStreamSplitter.for_profile(@profile)
+        # The prompt's prefill is the reply's start: an open thought there
+        # streams as thinking. What the seed itself splits into is the
+        # prompt's, not shown.
+        stream_splitter.feed(request.prefill) unless request.prefill.empty?
         # Each ask starts with streamed_any = false, but once any chunk of
         # this ask is shown it stays shown: a held-back partial marker after
         # real text must not clear it, or the drop below won't ask again.
@@ -635,7 +671,9 @@ module Samagotchi
         return :next
       end
 
-      response = generation.response
+      # The prefill is the reply's start: an open thought it began closes in
+      # the response, and the whole block goes from the answer.
+      response = request.prefill + generation.response.to_s
       answer = -> { PromptLiteralGuard.restore(strip_thought_blocks(response), profile: @profile) }
       empty = strip_thought_blocks(response.to_s).strip.empty?
       retry_empty = empty && turn.empty_retry.retry_empty?(iteration: turn.iteration,

data/lib/samagotchi/model_profile.rb

@@ -484,12 +484,11 @@ module Samagotchi
     private_class_method :configured
 
     # Only a native llama.cpp host has /props with a chat template; a chat
-    # host (api: openai or anthropic) barely uses a profile, and mlx/oMLX expose none.
+    # host (api: openai or anthropic) barely uses a profile.
     def self.probe?(entry, client)
       return false if client.nil? || !client.respond_to?(:server_props)
-      return false if entry&.chat?
 
-      client.transport.name == :llama_cpp
+      !entry&.chat?
     end
     private_class_method :probe?
 

data/lib/samagotchi/self_report.rb

@@ -345,8 +345,6 @@ module Samagotchi
       when :config then "#{name} (config #{result.detail})"
       when :cli, :env then "#{name} (#{result.source})"
       else
-        return "#{name} (#{result.source})" unless entry.nil? || entry.transport.nil? || entry.transport == :llama_cpp
-
         given = result.source == :name ? "name says #{name}" : "default #{name}"
         "from the server at runtime (#{given})"
       end

data/lib/samagotchi/system_prompt.rb

@@ -96,7 +96,7 @@ module Samagotchi
         @section_notes = nil
         @section_files = []
         @built[key] = system_prompt_with_index(
-          assist_system_prompt(chat: chat, thinking: thinking, layers: layers), chat: chat, thinking: thinking, layers: layers
+          assist_system_prompt(chat: chat, layers: layers), chat: chat, thinking: thinking, layers: layers
         )
         @index_sizes[key] = @measured_index
         @notes_loaded[key] = @section_notes || []
@@ -151,9 +151,8 @@ module Samagotchi
 
     # The base prompt (specs, plugins' declarations), with Gemma's tool
     # declarations at its end as #build has them.
-    def base(chat: false, thinking: nil, layers: [])
-      with_tail_declarations(assist_system_prompt(chat: chat, thinking: thinking, layers: layers), chat: chat,
-                                                                                                  layers: layers)
+    def base(chat: false, layers: [])
+      with_tail_declarations(assist_system_prompt(chat: chat, layers: layers), chat: chat, layers: layers)
     end
 
     # Names activated via preloaded --memory entries during prompt
@@ -195,27 +194,14 @@ module Samagotchi
       end
     end
 
-    # Only Qwen has an explicit thinking-close marker, so only Qwen can
-    # reliably have this preamble parsed back out of its thinking block.
-    # With thinking off there is no thinking to begin with it.
-    def turn_preamble_instruction(thinking = nil)
-      return "" unless profile.name == "qwen36"
-      return "" if Samagotchi::Config.get("thinking.turn_preamble") == false
-      return "" if (thinking || turn_thinking) == :off
-
-      "\nTurn preamble: as the very first line of your thinking, write \"TURN: \" followed by a short present-tense action phrase (max 8 words) describing what you are about to do, e.g. \"TURN: reading project config\". Then continue reasoning normally.\n"
-    end
-
     # ── System prompts ─────────────────────────────────────────────────────────
 
-    # @param chat [Boolean] for the chat loop: no tool declarations, call
-    #   syntax or turn preamble (its tools go as schemas with each request)
-    # @param thinking [Symbol, nil] the level (Thinking); nil: the effective model's
-    def assist_system_prompt(chat: false, thinking: nil, layers: [])
+    # @param chat [Boolean] for the chat loop: no tool declarations or call
+    #   syntax (its tools go as schemas with each request)
+    def assist_system_prompt(chat: false, layers: [])
       return chat_system_prompt if chat
 
       hint = tool_call_hint
-      turn_preamble = turn_preamble_instruction(thinking)
       # Gemma 4's template declares the tools at the end of the system turn
       # (#system_prompt_with_index puts them there).
       tools = if gemma_tail_declarations?
@@ -228,7 +214,7 @@ module Samagotchi
         You are Chi (pronounced "chee"), the friendly name for the Samagotchi assistant harness. #{tools}
         #{hint}
         You may make multiple tool calls. After seeing tool results, continue reasoning or answer the user.
-        #{turn_preamble}
+
         #{ToolDeclarations::SMALL_CONTEXT_PROTOCOL}
 
         #{assist_guidance}

data/lib/samagotchi/terminal_ui/thinking_line.rb

@@ -20,8 +20,6 @@ module Samagotchi
 
       # Enough text to find the newest sentence in; scanning grows with it.
       BUFFER_LIMIT = 2000
-      # The Qwen turn preamble's first line ("TURN: reading the config").
-      TURN_PREFIX = /\ATURN:\s*/i
       # Where a raw stream's thinking ends: a boundary, so its last words
       # don't run into the answer's first.
       THOUGHT_CLOSE = %r{<channel\|>|</think>}
@@ -65,8 +63,8 @@ module Samagotchi
       # @return [Symbol, nil] :thinking or :writing
       attr_reader :label
 
-      # The sentence as a row shows it: no TURN: prefix, markdown plain.
-      def sentence = strip_markdown(@ticker.line.sub(TURN_PREFIX, ""))
+      # The sentence as a row shows it: markdown plain.
+      def sentence = strip_markdown(@ticker.line)
 
       # #sentence cut to +room+ columns, with an ellipsis when cut.
       def fit(room)

data/lib/samagotchi/thinking.rb

@@ -27,6 +27,14 @@ module Samagotchi
     # An empty thought after the Qwen assistant cue: the model answers at once
     # (what the server's own template does with enable_thinking false).
     QWEN_EMPTY_THOUGHT = "<think>\n\n</think>\n\n"
+    # An open thought after the Qwen assistant cue, as a Qwen3.5+ template
+    # writes it with thinking on: without it Qwen3.6 writes an empty thought
+    # at once and never thinks (#opens_thought?).
+    QWEN_OPEN_THOUGHT = "<think>\n"
+    # A Jinja string literal that ends with the open thought: '<think>\n'
+    # (a Qwen3.5+ generation prompt). Qwen3's writes only the empty one,
+    # '<think>\n\n</think>\n\n', with thinking off.
+    OPEN_THOUGHT_LITERAL = /<think>(?:\\n|\n)['"]/
     # Gemma 4's empty thought channel after the model cue, as its chat
     # template writes it with enable_thinking false (only where a model turn
     # starts: Prompt.prefill_for).
@@ -168,15 +176,40 @@ module Samagotchi
       caps.is_a?(Hash) && caps["supports_reasoning_effort"] == false
     end
 
+    # Whether a llama.cpp /props answer (+props+, Client::ServerProps)
+    # carries a chat template whose generation prompt opens a thought
+    # (Qwen3.5 and later: `assistant\n` then '<think>\n' unless
+    # enable_thinking is false). Read from the template's last
+    # add_generation_prompt branch on: the message loop before it writes
+    # earlier turns' thoughts. false when there is no template (a router's
+    # own /props, an unloaded model, a failed probe).
+    def opens_thought?(props)
+      return false unless props.respond_to?(:answered?) && props.answered? && props.body.is_a?(Hash)
+
+      template = props.body["chat_template"]
+      return false unless template.is_a?(String)
+
+      cue = template.rindex("add_generation_prompt")
+      !cue.nil? && OPEN_THOUGHT_LITERAL.match?(template[cue..])
+    end
+
     # The native prompt's switch for +level+ under +profile+.
     # @param profile [ModelProfile]
+    # @param opens_thought [Boolean] the server's template opens a thought
+    #   after the cue (#opens_thought?): qwen36 then gets the open thought
+    #   at every level but off, as the template has it
     # @return [Native]
-    def native(level, profile)
+    def native(level, profile, opens_thought: false)
       off = level == :off
       honoured = !EFFORTS.include?(level)
       case profile&.name
       when "gemma4" then Native.new(system_token: off ? "" : GEMMA_THINK_TOKEN, prefill: off ? GEMMA_EMPTY_THOUGHT : "", honoured: honoured)
-      when "qwen36" then Native.new(system_token: "", prefill: off ? QWEN_EMPTY_THOUGHT : "", honoured: honoured)
+      when "qwen36"
+        prefill = if off then QWEN_EMPTY_THOUGHT
+                  elsif opens_thought then QWEN_OPEN_THOUGHT
+                  else ""
+                  end
+        Native.new(system_token: "", prefill: prefill, honoured: honoured)
       else Native.new(system_token: "", prefill: "", honoured: level == DEFAULT)
       end
     end