samagotchi 0.79.0 → 0.80.0

data/docs/testing.md

@@ -1,7 +1,9 @@
 # Testing
 
 ```sh
-bundle exec parallel_rspec -n 8   # Ruby specs, in parallel (or plain: bundle exec rspec)
+bundle exec parallel_rspec -n 8 spec lib/samagotchi/bundles/*/spec   # Ruby specs, both roots, in parallel
+bundle exec rspec spec lib/samagotchi/bundles/*/spec                 # the same, plain
+bundle exec rake bundles:specs    # the shipped bundles' own specs, on the bundle test kit alone
 npm test                          # web frontend specs
 npm run e2e                       # web UI happy paths in Chromium, fake model (once: npx playwright install chromium)
 npx playwright test spec/e2e/stage.spec.js   # one e2e file (the root playwright.config.js is the suite's)
@@ -53,6 +55,34 @@ Every example also runs under a 120 s limit (`spec_helper`'s `around`; `integrat
 `recap` examples are exempt), so a hang fails its example instead of the run. `SPEC_EXAMPLE_TIMEOUT=N` changes the
 limit, `0` turns it off (a debugger session).
 
+## Bundle specs: the test kit
+
+A shipped bundle's plugin and hook files are tested through the bundle test kit (`samagotchi/testing`,
+[plugins.md](plugins.md#testing-a-bundle-experimental)): `shipped_bundle("check-in", settings: …)` loads it through
+chi's own loaders, registries, `ctx` and guardrail Gate, with the session, the hook helpers and `ctx.sessions`
+recorded. No fake `chi` or `ctx`: what the kit can't express is a kit change (with a kit spec), not a local fake.
+
+These specs live **next to the bundle**, in `lib/samagotchi/bundles/<name>/spec/` (their fixtures in its
+`spec/fixtures/`), and require only `samagotchi/testing/rspec` (tagged `:bundle` by their path): no `spec_helper`, no
+`spec/support`, as an external bundle's specs would run. `rake bundles:specs` runs them that way
+(`rspec --options /dev/null -r samagotchi/testing/rspec`), in CI's bundles job; the full suite runs them too, under
+`spec_helper`, given both roots (plain `rspec` runs `spec/` only: `.rspec` holds no `--pattern`, which would make
+`rspec FILE` run everything). They are never shipped: the gem and an install leave `spec/` out, and the release
+tools' version check ignores a bundle's `spec/` (a spec-only change needs no bump). A spec that runs real turns
+(install → Engine → `run_turn`) stays in `spec/samagotchi/plugin/<name>_bundle_spec.rb`.
+
+The kit's own specs, in `spec/samagotchi/testing/`, keep it and the bundles honest:
+
+- `spec/samagotchi/testing/contract_spec.rb`: the kit sets every `Plugin::Host` and `Hooks::Runtime` member,
+  `Testing::Sessions` has `Plugin::Sessions`' methods and parameters, and each `ctx` helper lands in its recorder. A
+  member added to the Host fails it until the kit has it.
+- `spec/samagotchi/testing/shipped_bundles_spec.rb`: each shipped bundle with a plugin or hooks registers the same
+  commands, tools, hooks, inits, toolkits and sources loaded by the kit as installed and loaded by chi.
+- `spec/samagotchi/testing/boundary_spec.rb`, the boundary lint: each bundle's Ruby (plugin, hooks, scripts, specs)
+  reaches chi only through `Samagotchi::Testing::Boundary::ALLOWED` (the "Stable for bundles" list) and that
+  bundle's `Boundary::EXCEPTIONS` entry, each with why. A new internal reference fails it, and so does an exception
+  no longer used. Fix the reference (the kit or a stable API), or add the exception with its why.
+
 ## While you work: affected specs
 
 ```sh
@@ -73,7 +103,7 @@ The Ruby specs go to stdout; the node tests to run (`npm test` targets), "web ch
 hint for a hub class (named in too many specs to list) go to stderr. Nothing printed means nothing matched.
 
 It finds a change's own specs, not the regressions it causes elsewhere. So before committing, run the full suite
-(`bundle exec parallel_rspec -n 8`), unless your task says the coordinator runs it; the coordinator runs it at merge
+(`bundle exec parallel_rspec -n 8 spec lib/samagotchi/bundles/*/spec`), unless your task says the coordinator runs it; the coordinator runs it at merge
 either way.
 
 ## Worktrees

data/lib/samagotchi/bootstrap/config_writer.rb

@@ -6,6 +6,7 @@ require "fileutils"
 require "ipaddr"
 require_relative "../atomic_file"
 require_relative "../config"
+require_relative "../host_config"
 require_relative "../yaml_lines"
 require_relative "../redacted_inspect"
 
@@ -91,6 +92,8 @@ module Samagotchi
       end
 
       # The name of an existing entry that points at the same server, or nil.
+      # An api: anthropic entry and any other on one server are different
+      # hosts (Fireworks serves both protocols).
       def duplicate_of(fields)
         current_hosts.find { |_, existing| same_server?(existing, fields) }&.first
       end
@@ -267,15 +270,22 @@ module Samagotchi
       def same_server?(existing, fields)
         a = location(existing)
         b = location(fields)
-        a && b && a == b
+        a && b && a == b && anthropic?(existing) == anthropic?(fields)
       end
 
-      # [scheme-less host, port, path] of an entry.
+      def anthropic?(fields) = fields["api"].to_s.strip.downcase == "anthropic"
+
+      # [scheme-less host, port, path] of an entry. An api: anthropic url's
+      # path loses a trailing /v1 (the adapter adds it), and one with
+      # neither url: nor host: is Anthropic's own API (HostConfig's rule).
       def location(fields)
         url = fields["url"].to_s.strip
+        url = ANTHROPIC_URL if url.empty? && anthropic?(fields) && fields["host"].to_s.strip.empty? && fields["port"].to_s.strip.empty?
         unless url.empty?
           uri = URI.parse(url)
-          return [uri.host.to_s.downcase, uri.port, uri.path.to_s.chomp("/")]
+          path = uri.path.to_s.chomp("/")
+          path = path.delete_suffix("/v1") if anthropic?(fields)
+          return [uri.host.to_s.downcase, uri.port, path]
         end
         host = fields["host"].to_s.strip.downcase
         return nil if host.empty?

data/lib/samagotchi/bootstrap/probe.rb

@@ -7,6 +7,8 @@ require "uri"
 require "ipaddr"
 require_relative "../version"
 require_relative "../llm/openai_chat"
+require_relative "../llm/anthropic_messages"
+require_relative "../llm/dialect"
 require_relative "../llm/http"
 require_relative "../llm/api_key"
 require_relative "../host_keys"
@@ -15,9 +17,12 @@ require_relative "../redacted_inspect"
 module Samagotchi
   module Bootstrap
     # What `chi bootstrap TARGET` finds at a model server: llama.cpp's native
-    # API (/props), an OpenAI-compatible one (/v1/models), one that wants an
-    # API key, or nothing. One attempt per request, no retries: a refused
-    # port answers at once instead of after chi's usual backoff.
+    # API (/props), an OpenAI-compatible one (/v1/models), Anthropic's
+    # Messages API (its /v1/models, asked only after the OpenAI list was
+    # refused with 400/401/403: the Anthropic list reads an OpenAI-shaped
+    # one too), one that wants an API key, or nothing. One attempt per
+    # request, no retries: a refused port answers at once instead of after
+    # chi's usual backoff.
     class Probe
       include RedactedInspect
 
@@ -31,6 +36,14 @@ module Samagotchi
       SCAN_TIMEOUT = 1
       TEST_TIMEOUT = 60
       TEST_PROMPT = "Reply with the word ok."
+      # The OpenAI list's statuses after which the Anthropic list is asked:
+      # Anthropic answers a Bearer request 400 (no anthropic-version) or
+      # 401/403. Not 404/405: a typed URL path sends the two lists to
+      # different paths, so a 404 there says nothing about Anthropic.
+      ANTHROPIC_AFTER = [400, 401, 403].freeze
+      AUTH_STATUSES = [401, 403].freeze
+      FIREWORKS_HOST = "fireworks.ai"
+      FIREWORKS_MODEL_PREFIX = "accounts/fireworks/"
 
       # One place a server may be: root is scheme://host:port (llama.cpp's
       # /props), base the OpenAI API base (<root>/v1, or a URL's own path).
@@ -44,17 +57,34 @@ module Samagotchi
         def label = "#{host}:#{port}"
       end
 
-      # kind: :native, :openai, :needs_key, :unreachable or :unknown.
-      # props: the /props JSON (native); models: [LLM::ModelInfo];
+      # kind: :native, :openai, :anthropic, :needs_key, :unreachable or
+      # :unknown. props: the /props JSON (native); models: [LLM::ModelInfo];
       # status: the HTTP status that decided (:unknown, :needs_key);
-      # reason: why it's unreachable.
-      Result = Data.define(:kind, :candidate, :props, :models, :status, :reason) do
-        def self.of(kind, candidate, props: nil, models: [], status: nil, reason: nil)
-          new(kind: kind, candidate: candidate, props: props, models: models, status: status, reason: reason)
+      # reason: why it's unreachable; dialect: an :anthropic result's
+      # LLM::Dialect name when not the standard one ("fireworks"), else nil;
+      # auth: :bearer when an :anthropic list took the key only as Bearer
+      # (a Symbol, LLM::ApiKey::SCHEMES), else nil.
+      Result = Data.define(:kind, :candidate, :props, :models, :status, :reason, :dialect, :auth) do
+        def self.of(kind, candidate, props: nil, models: [], status: nil, reason: nil, dialect: nil, auth: nil)
+          new(kind: kind, candidate: candidate, props: props, models: models, status: status, reason: reason,
+              dialect: dialect, auth: auth)
         end
 
         def native? = kind == :native
-        def reached? = %i[native openai].include?(kind)
+        def anthropic? = kind == :anthropic
+        def reached? = %i[native openai anthropic].include?(kind)
+      end
+
+      # A failed test turn: the message, and the HTTP status and request path
+      # when the server answered (BootstrapCommand's --api anthropic hint).
+      class TestFailed < RuntimeError
+        attr_reader :status, :path
+
+        def initialize(message = nil, status: nil, path: nil)
+          @status = status
+          @path = path
+          super(message)
+        end
       end
 
       # The target the user typed, as the candidates to try in order.
@@ -110,6 +140,21 @@ module Samagotchi
         false
       end
 
+      # The Messages API root: the OpenAI base without its trailing /v1
+      # (HostEntry#api_base_url's rule), e.g. https://api.anthropic.com.
+      def self.api_root(candidate) = candidate.base.chomp("/").delete_suffix("/v1")
+
+      # Fireworks by its host (fireworks.ai or a subdomain), or by a model id
+      # in its accounts/fireworks/ namespace.
+      def self.fireworks?(candidate, models = [])
+        fireworks_host?(candidate.host) || models.any? { |m| m.id.to_s.start_with?(FIREWORKS_MODEL_PREFIX) }
+      end
+
+      def self.fireworks_host?(host)
+        name = host.to_s.downcase
+        name == FIREWORKS_HOST || name.end_with?(".#{FIREWORKS_HOST}")
+      end
+
       def self.parse_uri(text)
         URI.parse(text)
       rescue URI::InvalidURIError
@@ -128,18 +173,27 @@ module Samagotchi
       # when this one refused the connection or failed its TLS handshake
       # (https → http), not on a timeout.
       # @param key_env [String, nil] the API key's environment variable
+      # @param api [Symbol, nil] :openai or :anthropic to skip the detection
+      #   (--api); nil detects
+      # @param dialect [String, nil] the Messages dialect (--dialect); nil
+      #   detects Fireworks
       # @return [Result]
-      def classify_target(candidates, key_env: nil)
+      def classify_target(candidates, key_env: nil, api: nil, dialect: nil)
         result = nil
         candidates.each do |candidate|
-          result = classify(candidate, key_env: key_env)
+          result = classify(candidate, key_env: key_env, api: api, dialect: dialect)
           break unless result.kind == :unreachable && result.reason.to_s.match?(/refused|SSL|TLS|certificate/i)
         end
         result
       end
 
+      # /props (llama.cpp), then the OpenAI list, then (only after the OpenAI
+      # list's 400/401/403) the Anthropic one. api: :anthropic asks only the
+      # Anthropic list; api: :openai never asks it.
       # @return [Result]
-      def classify(candidate, key_env: nil)
+      def classify(candidate, key_env: nil, api: nil, dialect: nil)
+        return classify_anthropic(candidate, key_env, dialect, nil) if api&.to_sym == :anthropic
+
         props = begin
           status, body = get(URI("#{candidate.root}/props"), key_env)
           status == 200 ? parse_object(body) : nil
@@ -151,8 +205,9 @@ module Samagotchi
         begin
           Result.of(:openai, candidate, models: list_models(candidate.base, key_env))
         rescue LLM::ProviderError => e
-          kind = [401, 403].include?(e.status) ? :needs_key : :unknown
-          Result.of(kind, candidate, status: e.status, reason: e.status ? nil : e.message)
+          return failure(candidate, e) if api || !ANTHROPIC_AFTER.include?(e.status)
+
+          classify_anthropic(candidate, key_env, dialect, e)
         rescue *network_errors => e
           Result.of(:unreachable, candidate, reason: reason(e))
         end
@@ -178,25 +233,27 @@ module Samagotchi
 
       # One short chat request: does the server generate for +model+? Any 200
       # with a choice counts (a thinking model may spend its 16 tokens
-      # reasoning). @return [Float] seconds taken
-      # @raise [RuntimeError] with what went wrong
-      def test_turn(candidate, model, key_env: nil, read_timeout: TEST_TIMEOUT)
-        uri = URI("#{candidate.base}/chat/completions")
-        request = Net::HTTP::Post.new(uri)
-        request["Content-Type"] = "application/json"
-        request.body = JSON.generate(model: model, messages: [{ role: "user", content: TEST_PROMPT }], max_tokens: 16,
-                                     stream: false)
+      # reasoning). api: :anthropic posts {root}/v1/messages instead, and any
+      # 200 with a content array counts (stop_reason max_tokens too).
+      # @param auth [Symbol, nil] the key's header on :anthropic (nil: the
+      #   dialect's)
+      # @return [Float] seconds taken
+      # @raise [TestFailed] with what went wrong
+      def test_turn(candidate, model, key_env: nil, api: :openai, dialect: nil, auth: nil, read_timeout: TEST_TIMEOUT)
+        anthropic = api&.to_sym == :anthropic
+        uri, request, scheme = anthropic ? messages_request(candidate, model, dialect, auth) : chat_request(candidate, model)
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        response = send_request(uri, request, key_env, read_timeout: read_timeout)
+        response = send_request(uri, request, key_env, read_timeout: read_timeout, scheme: scheme)
         elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
         body = parse_object(response.body)
-        unless response.code.to_i == 200 && body && body["choices"].is_a?(Array) && !body["choices"].empty?
-          raise "HTTP #{response.code}: #{error_text(body, response.body)}"
+        unless response.code.to_i == 200 && answered?(body, anthropic ? "content" : "choices")
+          raise TestFailed.new("HTTP #{response.code}: #{error_text(body, response.body)}", status: response.code.to_i,
+                                                                                          path: uri.path)
         end
 
         elapsed
       rescue *network_errors => e
-        raise "#{reason(e)} (#{candidate.label})"
+        raise TestFailed, "#{reason(e)} (#{candidate.label})"
       end
 
       private
@@ -224,16 +281,81 @@ module Samagotchi
                             timeout: @timeout, env: @env).list_models
       end
 
+      # The Anthropic list at the candidate's API root, the key in the
+      # dialect's header (Bearer on Fireworks, detected by its host before
+      # listing); a 401/403 with the standard dialect's x-api-key is asked
+      # once more with Bearer (a gateway that wants it). Ids in Fireworks'
+      # namespace make the result's dialect fireworks. +openai_error+ is the
+      # OpenAI list's refusal, the result again when the Anthropic list fails
+      # other than 401/403 (nil when --api anthropic skipped it).
+      def classify_anthropic(candidate, key_env, dialect, openai_error)
+        forced = dialect
+        dialect ||= LLM::Dialect::FIREWORKS.name if self.class.fireworks_host?(candidate.host)
+        auth = nil
+        models = begin
+          anthropic_models(candidate, key_env, dialect: dialect, auth: nil)
+        rescue LLM::ProviderError => e
+          raise unless AUTH_STATUSES.include?(e.status) && key_env && LLM::Dialect.for(dialect).auth != :bearer
+
+          auth = :bearer
+          anthropic_models(candidate, key_env, dialect: dialect, auth: auth)
+        end
+        dialect ||= LLM::Dialect::FIREWORKS.name if forced.nil? && self.class.fireworks?(candidate, models)
+        dialect = nil if dialect == LLM::Dialect::STANDARD.name
+        Result.of(:anthropic, candidate, models: models, dialect: dialect, auth: auth)
+      rescue LLM::ProviderError => e
+        return Result.of(:needs_key, candidate, status: e.status) if AUTH_STATUSES.include?(e.status)
+
+        failure(candidate, openai_error || e)
+      rescue *network_errors => e
+        Result.of(:unreachable, candidate, reason: reason(e))
+      end
+
+      def anthropic_models(candidate, key_env, dialect:, auth:)
+        LLM::AnthropicMessages.new(base_url: self.class.api_root(candidate), host_name: candidate.host, api_key_env: key_env,
+                                   auth: auth, dialect: dialect, stream: false, retries: false, timeout: @timeout,
+                                   env: @env).list_models
+      end
+
+      # A list's refusal as a Result: :needs_key on 401/403, else :unknown.
+      def failure(candidate, error)
+        kind = AUTH_STATUSES.include?(error.status) ? :needs_key : :unknown
+        Result.of(kind, candidate, status: error.status, reason: error.status ? nil : error.message)
+      end
+
+      def chat_request(candidate, model)
+        uri = URI("#{candidate.base}/chat/completions")
+        request = json_post(uri, model: model, messages: [{ role: "user", content: TEST_PROMPT }], max_tokens: 16, stream: false)
+        [uri, request, :bearer]
+      end
+
+      # No stream and no thinking field: the model's own defaults.
+      def messages_request(candidate, model, dialect, auth)
+        uri = URI("#{self.class.api_root(candidate)}/v1/messages")
+        request = json_post(uri, model: model, max_tokens: 16, messages: [{ role: "user", content: TEST_PROMPT }])
+        request["anthropic-version"] = LLM::AnthropicMessages::API_VERSION
+        [uri, request, auth || LLM::Dialect.for(dialect).auth]
+      end
+
+      def json_post(uri, body)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(body)
+        request
+      end
+
+      def answered?(body, key) = body.is_a?(Hash) && body[key].is_a?(Array) && !body[key].empty?
+
       def get(uri, key_env)
         response = send_request(uri, Net::HTTP::Get.new(uri), key_env, read_timeout: @timeout)
         [response.code.to_i, response.body]
       end
 
-      # One attempt through LLM::HTTP (User-Agent, the key's Bearer header),
-      # any status returned as is. A key neither its variable nor the
+      # One attempt through LLM::HTTP (User-Agent, the key in +scheme+'s
+      # header), any status returned as is. A key neither its variable nor the
       # Keychain holds sends no header: the server's 401 then says one is needed.
-      def send_request(uri, request, key_env, read_timeout:)
-        key = key_env && HostKeys.fetch(key_env, env: @env) ? LLM::ApiKey.for(key_env, host: uri.host, env: @env) : nil
+      def send_request(uri, request, key_env, read_timeout:, scheme: :bearer)
+        key = key_env && HostKeys.fetch(key_env, env: @env) ? LLM::ApiKey.for(key_env, host: uri.host, env: @env, scheme: scheme) : nil
         LLM::HTTP.new(label: uri.host, open_timeout: @timeout, read_timeout: read_timeout, api_key: key,
                       retry_policy: LLM::HTTP::RetryPolicy.none)
                  .fetch(uri, request, retries: false, check_status: false, log_fields: { purpose: "probe" })

data/lib/samagotchi/bootstrap_command.rb

@@ -14,9 +14,10 @@ require_relative "redacted_inspect"
 
 module Samagotchi
   # `chi bootstrap [TARGET]`: the first setup. It names a model server, works
-  # out what it is (llama.cpp's native API or an OpenAI-compatible one),
-  # picks the model, sends one test request and writes config.yml: a fresh
-  # file, or a hosts: entry added to an existing one. Then it installs the
+  # out what it is (llama.cpp's native API, an OpenAI-compatible one or
+  # Anthropic's Messages API, Bootstrap::Probe), picks the model, sends one
+  # test request and writes config.yml: a fresh file, or a hosts: entry
+  # added to an existing one. Then it installs the
   # system bundle and the core profile, and on a terminal asks about dev.
   # Prompts only on a terminal; a script gets the list and exit 2 instead.
   class BootstrapCommand
@@ -24,11 +25,14 @@ module Samagotchi
     include RedactedInspect
 
     USAGE = <<~TEXT
-      Usage: chi bootstrap [TARGET] [--name NAME] [--model ID] [--key-env VAR] [--no-test] [--dry-run]
+      Usage: chi bootstrap [TARGET] [--name NAME] [--model ID] [--key-env VAR] [--api API] [--dialect NAME]
+                           [--no-test] [--dry-run]
         Finds the model server at TARGET and writes config.yml for it.
           chi bootstrap 192.168.1.29:8081          llama.cpp on the LAN
           chi bootstrap localhost:11434            Ollama
           chi bootstrap https://openrouter.ai/api/v1 --key-env OPENROUTER_API_KEY
+          chi bootstrap https://api.anthropic.com --key-env ANTHROPIC_API_KEY
+          chi bootstrap https://api.fireworks.ai/inference/v1 --key-env FIREWORKS_API_KEY --api anthropic
           chi bootstrap                            look on this machine's usual ports
         TARGET        host[:port] (port 8080 when none), or a URL; a URL's
                       path is the OpenAI API base
@@ -37,6 +41,12 @@ module Samagotchi
         --model ID    the model, when the server has several
         --key-env VAR the environment variable holding the API key (the
                       key itself is never written)
+        --api API     openai or anthropic (Anthropic's Messages API) instead
+                      of detecting it; detection takes anthropic only when
+                      the OpenAI model list is refused
+        --dialect NAME the Messages API's dialect: standard or fireworks
+                      (implies --api anthropic; default: fireworks when the
+                      host or the model ids say so)
         --no-test     skip the test request
         --dry-run     show what would be written; write nothing
         With no config.yml it writes one; an existing one gets a hosts:
@@ -50,10 +60,13 @@ module Samagotchi
       f.value "--name"
       f.value "--model"
       f.value "--key-env"
+      f.value "--api"
+      f.value "--dialect"
       f.switch "--no-test"
       f.switch "--dry-run"
     end
 
+    APIS = %i[openai anthropic].freeze
     PICK_SHOWN = 20
     # A test request slower than this says it is waiting (a model loading).
     LOADING_AFTER = 3
@@ -92,6 +105,8 @@ module Samagotchi
         return @exit
       end
 
+      @api = options[:api]
+      @dialect = options[:dialect]
       result = find(options, key_env) or return @exit
       unlocked = with_key(result, key_env) or return @exit
       result, key_env = unlocked
@@ -124,7 +139,25 @@ module Samagotchi
         return usage_error("--key-env takes the variable's name (e.g. OPENROUTER_API_KEY), not the key")
       end
 
-      options
+      parse_api(options)
+    end
+
+    # --api as a Symbol, --dialect downcased (implying --api anthropic).
+    def parse_api(options)
+      if options[:api]
+        api = options[:api].strip.downcase.to_sym
+        return usage_error("--api must be #{APIS.join(" or ")} (got #{options[:api]})") unless APIS.include?(api)
+
+        options[:api] = api
+      end
+      return options unless options[:dialect]
+
+      dialect = options[:dialect].strip.downcase
+      names = LLM::Dialect::BY_NAME.keys
+      return usage_error("--dialect must be #{names.join(" or ")} (got #{options[:dialect]})") unless names.include?(dialect)
+      return usage_error("--dialect is for --api anthropic, not --api openai") if options[:api] == :openai
+
+      options.merge(dialect: dialect, api: :anthropic)
     end
 
     # The server's Probe::Result, or nil with @exit set.
@@ -137,17 +170,26 @@ module Samagotchi
         @exit = usage_error(e.message)
         return nil
       end
-      result = @probe.classify_target(candidates, key_env: key_env)
+      result = @probe.classify_target(candidates, key_env: key_env, api: @api, dialect: @dialect)
       case result.kind
       when :unreachable
         fail!("can't reach #{result.candidate.label} (#{result.reason})")
       when :unknown
         detail = result.status ? "HTTP #{result.status}" : result.reason
-        fail!("reached #{result.candidate.label} but it answers neither llama.cpp /props nor /v1/models (#{detail})")
+        fail!("reached #{result.candidate.label} but it answers #{unknown_asked} (#{detail})")
       else result
       end
     end
 
+    # What an :unknown server didn't answer, by what --api let the probe ask.
+    def unknown_asked
+      case @api
+      when :anthropic then "no Anthropic /v1/models"
+      when :openai then "neither llama.cpp /props nor /v1/models"
+      else "neither llama.cpp /props, /v1/models nor the Anthropic /v1/models"
+      end
+    end
+
     def scan
       found = @probe.scan_local
       ports = Bootstrap::Probe::LOCAL_PORTS.keys.join(", ")
@@ -190,7 +232,7 @@ module Samagotchi
       return fail!("#{key_env} isn't a variable name") unless key_env.match?(ConfigFile::ENV_NAME_RE)
       return fail!("#{key_env} is not set; #{export_hint(key_env, "and run chi bootstrap again")}") if unset?(key_env)
 
-      result = @probe.classify(result.candidate, key_env: key_env)
+      result = @probe.classify(result.candidate, key_env: key_env, api: @api, dialect: @dialect)
       return fail!("#{host} refused the key in #{key_env} (HTTP #{result.status})") if result.kind == :needs_key
       return fail!("can't reach #{host} (#{result.reason || "HTTP #{result.status}"})") unless result.reached?
 
@@ -201,8 +243,15 @@ module Samagotchi
       if result.native?
         build = result.props["build_info"].to_s
         @stdout.puts("found: llama.cpp at #{result.candidate.root}#{" (build #{build})" unless build.empty?}")
+      elsif result.anthropic?
+        dialect = " (dialect: #{result.dialect})" if result.dialect
+        @stdout.puts("found: an Anthropic Messages API at #{Bootstrap::Probe.api_root(result.candidate)}#{dialect}")
       else
         @stdout.puts("found: an OpenAI-compatible API at #{result.candidate.base}")
+        # By the host only: a proxy listing accounts/fireworks/ ids may not serve /v1/messages.
+        if @api.nil? && Bootstrap::Probe.fireworks_host?(result.candidate.host)
+          @stdout.puts("Fireworks also serves the Anthropic Messages API: --api anthropic")
+        end
       end
     end
 
@@ -248,17 +297,28 @@ module Samagotchi
                     @stdout.puts("test: waiting for an answer (loading the model?)…") if done.pop(timeout: LOADING_AFTER).nil?
                   end
                 end
-      seconds = @probe.test_turn(result.candidate, model, key_env: key_env)
+      seconds = @probe.test_turn(result.candidate, model, key_env: key_env, api: result.anthropic? ? :anthropic : :openai,
+                                                          dialect: result.dialect, auth: result.auth)
       @stdout.puts(format("test: answered in %.1f s", seconds))
       true
     rescue StandardError => e
-      @stdout.puts("test: failed: #{e.message}")
+      @stdout.puts("test: failed: #{e.message}#{messages_hint(result, e)}")
       false
     ensure
       done&.push(true)
       waiting&.join
     end
 
+    # A detected OpenAI server whose model list worked but whose
+    # /chat/completions is 404: maybe a Messages-only url (a gateway's
+    # Anthropic route that also lists the OpenAI way).
+    def messages_hint(result, error)
+      return "" unless @api.nil? && result.kind == :openai && error.is_a?(Bootstrap::Probe::TestFailed)
+      return "" unless error.status == 404 && error.path.to_s.end_with?("/chat/completions")
+
+      " (an Anthropic Messages API? try --api anthropic)"
+    end
+
     # The "loading the model?" hint fits a local server (a llama.cpp loading
     # weights); a remote provider's slow answer is the network, not a load.
     def loading_hint?(result)
@@ -268,7 +328,7 @@ module Samagotchi
     # 0 written, 1 written but not as planned, nil with @exit on a refusal.
     def write(result, model, key_env, options)
       writer = Bootstrap::ConfigWriter.new(path: @config_path, env: @env)
-      fields = host_fields(result.candidate, result.native?, key_env)
+      fields = host_fields(result, key_env)
       ids = result.models.map(&:id)
       base = Bootstrap::ConfigWriter.derived_name(result.candidate.host)
       name, reason = begin
@@ -350,18 +410,35 @@ module Samagotchi
     end
 
     # The hosts entry: host/port for a plain http server (api: openai when it
-    # isn't llama.cpp), url for https or a URL with its own path.
-    def host_fields(candidate, native, key_env)
+    # isn't llama.cpp), url for https or a URL with its own path (an
+    # Anthropic one without /v1: the API root, as the hand-written claude
+    # host has it). Then api, dialect, auth (Bearer only when the dialect's
+    # own header isn't), api_key_env.
+    def host_fields(result, key_env)
+      candidate = result.candidate
       fields = if candidate.url || candidate.scheme == "https"
-                 { "url" => native ? candidate.root : candidate.base }
+                 { "url" => url_field(result) }
                else
                  { "host" => candidate.host, "port" => candidate.port }
                end
-      fields["api"] = "openai" unless native
+      if result.anthropic?
+        fields["api"] = "anthropic"
+        fields["dialect"] = result.dialect if result.dialect
+        fields["auth"] = result.auth.to_s if result.auth && result.auth != LLM::Dialect.for(result.dialect).auth
+      elsif !result.native?
+        fields["api"] = "openai"
+      end
       fields["api_key_env"] = key_env if key_env
       fields
     end
 
+    def url_field(result)
+      return result.candidate.root if result.native?
+      return Bootstrap::Probe.api_root(result.candidate) if result.anthropic?
+
+      result.candidate.base
+    end
+
     def report(outcome, model)
       path = outcome.path
       case outcome.kind

data/lib/samagotchi/bridge.rb

@@ -658,7 +658,7 @@ module Samagotchi
 
       begin
         result = @engine.answer_question(id: qid, selected: selected, freeform: freeform, client_id: client_id)
-        [{}, 200, { status: "answered", session_id: session_id, answer: result }]
+        [{}, 200, { status: "answered", session_id: session_id, answer: result.to_h }]
       rescue Engine::QuestionNotPending => e
         # Another client answered first, or the question was cancelled.
         [{}, 409, { error: "question_not_pending", detail: e.message }]

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

@@ -1,11 +1,11 @@
 ---
 name: samagotchi-system
-version: 0.79.0
+version: 0.80.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:b5b3166c91f6f2af2563dd9db5f9959cda66747d907017acd0776fcd2fe29049
+  self_map.md: sha256:4ff5708e51f55089de47b107643ae0b74aee04cb96111226823a8d44fb4bc33d
   config_modification_protocol.md: sha256:66792f788cdbb8ee0252f2c387c96bd75266817bb75f721aaa181b602db97137
   memory_guide.md: sha256:c48eea744db69e4f3e9bb415e9a03a8c78bbcaa1205ad3b1fb157a079f92d22e
   delegated.md: sha256:a0d6ddcd4a8be06526d964898611775fd251cfd9d145a9d16afaccaa503597bd

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

@@ -48,7 +48,7 @@
   approvals (I see only how each was answered); see `docs/sessions.md` "Delegating".
 - Bundles extend me: memories, `hooks/*.rb`, `guardrails/*.yml`, and a `plugin.rb` that adds slash
   commands (`anytime:` ones run mid-turn), model tools (they can return images I see), hooks,
-  cards, side answers (`ask_model`),
+  cards, side answers (`ask_model`), HTTP calls (`ctx.http`),
   child sessions and services (e.g. MCP server processes). Shipped: `btw` (`/btw` side question),
   `mcp` (MCP server tools, searched with find_tools and called with call_tool; a screenshot comes as a picture; a toolkit's undeclared built-ins too, as chi/<tool>), `guardrails` (rules), `known-names` (typo guard), `source-links`
   (turns source refs like JIRA-123 in an answer into links in the web, and a one-line note), `loop-guard`

data/lib/samagotchi/continue_offer.rb

@@ -211,13 +211,13 @@ module Samagotchi
     def answered(answer, client_id:)
       # The /continue line takes the text on one line; the steer keeps its
       # line breaks.
-      text = answer[:freeform].to_s.gsub(/\s+/, " ").strip
+      text = answer.freeform.to_s.gsub(/\s+/, " ").strip
       @continue_steer = nil
-      if Array(answer[:selected]).include?(CONTINUE) && !text.empty?
-        @continue_steer = { text: answer[:freeform].to_s.strip,
-                            source: answer[:by] == "parent_agent" ? "parent_agent" : "user" }
+      if answer.selected.include?(CONTINUE) && !text.empty?
+        @continue_steer = { text: answer.freeform.to_s.strip,
+                            source: answer.parent_agent? ? "parent_agent" : "user" }
       end
-      line = if Array(answer[:selected]).include?(CONTINUE) then "/continue yes"
+      line = if answer.selected.include?(CONTINUE) then "/continue yes"
              elsif text.empty? then "/continue no"
              else "/continue no, #{text}"
              end