agentprov-capture 0.1.1__tar.gz

agentprov_capture-0.1.1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: agentprov-capture
+Version: 0.1.1
+Summary: AgentPROV capture/0.1 raw-evidence event log: model, writer, hash-chain verifier, redaction. Stdlib + rfc8785 only; shared by the AgentPROV core (reader) and the isolated live backends (writer).
+Author: Nicholas Jones
+License-Expression: MIT
+Requires-Dist: rfc8785>=0.1.4
+Requires-Python: >=3.12
+Project-URL: Homepage, https://w3id.org/agentprov/
+Project-URL: Documentation, https://w3id.org/agentprov/docs/
+Project-URL: Source, https://github.com/nickjones39/AgentPROV
+Description-Content-Type: text/markdown
+
+# agentprov-capture
+
+The `capture/0.1` raw-evidence event log of [AgentPROV](https://w3id.org/agentprov/): its model, the writer that live
+backends use to record an agent run, the hash-chain verifier and the redaction of credentials. Standard library plus
+`rfc8785` only, so it installs in the isolated backend environments (Python 3.12 and later) as well as in the core.
+
+You normally get it as a dependency of [`agentprov`](https://pypi.org/project/agentprov/). The format is specified in
+the AgentPROV repository (`docs/architecture/`, <https://github.com/nickjones39/AgentPROV>), and the user guide is at
+<https://w3id.org/agentprov/docs/>.
+
+MIT licence.

agentprov_capture-0.1.1/README.md

@@ -0,0 +1,11 @@
+# agentprov-capture
+
+The `capture/0.1` raw-evidence event log of [AgentPROV](https://w3id.org/agentprov/): its model, the writer that live
+backends use to record an agent run, the hash-chain verifier and the redaction of credentials. Standard library plus
+`rfc8785` only, so it installs in the isolated backend environments (Python 3.12 and later) as well as in the core.
+
+You normally get it as a dependency of [`agentprov`](https://pypi.org/project/agentprov/). The format is specified in
+the AgentPROV repository (`docs/architecture/`, <https://github.com/nickjones39/AgentPROV>), and the user guide is at
+<https://w3id.org/agentprov/docs/>.
+
+MIT licence.

agentprov_capture-0.1.1/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "agentprov-capture"
+version = "0.1.1"
+description = "AgentPROV capture/0.1 raw-evidence event log: model, writer, hash-chain verifier, redaction. Stdlib + rfc8785 only; shared by the AgentPROV core (reader) and the isolated live backends (writer)."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+dependencies = ["rfc8785>=0.1.4"]
+
+[[project.authors]]
+name = "Nicholas Jones"
+
+[project.urls]
+Homepage = "https://w3id.org/agentprov/"
+Documentation = "https://w3id.org/agentprov/docs/"
+Source = "https://github.com/nickjones39/AgentPROV"
+
+[build-system]
+requires = ["uv_build>=0.12.18,<0.13"]
+build-backend = "uv_build"

agentprov_capture-0.1.1/pyproject.toml.orig

@@ -0,0 +1,18 @@
+[project]
+name = "agentprov-capture"
+version = "0.1.1"
+description = "AgentPROV capture/0.1 raw-evidence event log: model, writer, hash-chain verifier, redaction. Stdlib + rfc8785 only; shared by the AgentPROV core (reader) and the isolated live backends (writer)."
+readme = "README.md"
+requires-python = ">=3.12"           # live backends run Python 3.12 (AgentDojo 0.1.35 baseline parity)
+license = "MIT"
+authors = [{ name = "Nicholas Jones" }]
+dependencies = ["rfc8785>=0.1.4"]
+
+[project.urls]
+Homepage = "https://w3id.org/agentprov/"
+Documentation = "https://w3id.org/agentprov/docs/"
+Source = "https://github.com/nickjones39/AgentPROV"
+
+[build-system]
+requires = ["uv_build>=0.12.18,<0.13"]
+build-backend = "uv_build"

agentprov_capture-0.1.1/src/agentprov_capture/__init__.py

@@ -0,0 +1,5 @@
+"""agentprov_capture: the capture/0.1 raw-evidence event log shared by the AgentPROV core (reader and
+verifier) and the isolated live backends (writer). Stdlib + rfc8785 only, Python >= 3.12."""
+
+FORMAT = "capture/0.1"
+__version__ = "0.1.1"  # equals capture/pyproject.toml (tests/unit/test_versions_source.py)

agentprov_capture-0.1.1/src/agentprov_capture/endpoints.py

@@ -0,0 +1,252 @@
+"""The endpoint registry: ``endpoints.toml`` as validated data (MN M.1.10 item 2; N.2.1, N.2.1a; G.9.2).
+
+Stdlib only (``tomllib``; Python >= 3.12). The registry names environment variables, never values. Rules enforced here:
+
+* a base URL is https, except loopback (``127.0.0.1``, ``[::1]``, ``localhost``);
+* a base URL has no userinfo, query or fragment (a key could hide in them; G.6.4);
+* a ``local`` entry is loopback and names its ``server`` kind (D-690). Its ``api_key_env`` is optional: a server set up
+  with an API key (oMLX's, D-827) gets it as a bearer header when the key is set, and none otherwise. A non-local entry
+  names ``api_key_env`` and has no ``server``;
+* a custom base URL's host must equal the registered host unless the caller passes ``allow_custom=True``
+  (the CLI's ``--allow-custom-endpoint``, recorded in the manifest);
+* ``api`` names the wire format the endpoint speaks: ``openai_chat`` (the default; OpenAI-compatible chat completions)
+  or ``anthropic_messages`` (the Anthropic Messages API; D-656).
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import re
+import tomllib
+from dataclasses import dataclass
+from importlib import resources
+from typing import Any, Final
+from urllib.parse import urlsplit
+
+__all__ = [
+    "API_KINDS",
+    "LOCAL_SERVERS",
+    "LOOPBACK_HOSTS",
+    "Endpoint",
+    "EndpointError",
+    "check_base_url",
+    "get_endpoint",
+    "is_loopback_host",
+    "is_private_lan_host",
+    "load_endpoints",
+    "parse_registry",
+    "validate_base_url",
+]
+
+#: The loopback hosts of G.9.2, as ``urllib.parse`` reports them (brackets removed from the IPv6 literal).
+LOOPBACK_HOSTS: Final = frozenset({"127.0.0.1", "::1", "localhost"})
+
+#: The wire formats an endpoint may speak (``api``); the first is the default.
+API_KINDS: Final = ("openai_chat", "anthropic_messages")
+#: The local server kinds of D-690. ``server`` selects the discovery and fingerprint probes of ``agentprov models``.
+LOCAL_SERVERS: Final = frozenset({"ollama", "omlx", "lmstudio", "mlx_lm", "llamacpp", "vllm"})
+
+_ENV_NAME: Final = re.compile(r"[A-Z][A-Z0-9_]{0,63}")
+_ENDPOINT_NAME: Final = re.compile(r"[a-z][a-z0-9_-]{0,31}")
+_HEADER_NAME: Final = re.compile(r"[a-z0-9][a-z0-9-]{0,63}")
+_ENTRY_KEYS: Final = frozenset(
+    {
+        "base_url",
+        "base_url_env",
+        "api_key_env",
+        "model_env",
+        "local",
+        "server_max_concurrency",
+        "request_headers",
+        "response_headers",
+        "api",
+        "server",
+    }
+)
+
+
+class EndpointError(ValueError):
+    """A registry or base-URL violation. ``code`` is stable; messages never carry values from the environment."""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(f"{code}: {message}")
+        self.code = code
+
+
+@dataclass(frozen=True, slots=True)
+class Endpoint:
+    """One registry entry. ``*_env`` fields are environment-variable NAMES (or None), never values."""
+
+    name: str
+    base_url: str
+    host: str
+    base_url_env: str | None
+    api_key_env: str | None
+    model_env: str | None
+    local: bool
+    server_max_concurrency: int | None
+    #: header NAMES (lower case) whose values wire-capture redaction may record besides the global allowlist
+    #: (``redact_allowlist.toml``): for example an API-version header (request) or a request-id header (response).
+    #: The hard denylist of G.6.4 wins over them.
+    request_headers: tuple[str, ...] = ()
+    response_headers: tuple[str, ...] = ()
+    #: the wire format (one of :data:`API_KINDS`): which LLM element and recorder the harness uses (D-656)
+    api: str = API_KINDS[0]
+    #: the local server kind (one of :data:`LOCAL_SERVERS`) for a ``local`` entry; ``None`` for a remote one (D-690)
+    server: str | None = None
+
+
+def is_loopback_host(host: str) -> bool:
+    return host.lower() in LOOPBACK_HOSTS
+
+
+#: The private ranges a LAN endpoint may use (D-698): RFC 1918, the shared address space of RFC 6598 (CGNAT, used by
+#: Tailscale-style overlays), and IPv6 unique local addresses. Link-local, loopback and every public range are not.
+LAN_NETWORKS: Final = tuple(ipaddress.ip_network(n) for n in (
+    "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "100.64.0.0/10", "fc00::/7"))
+
+
+def is_private_lan_host(host: str) -> bool:
+    """A literal IP address in :data:`LAN_NETWORKS` (never a name: a name can be made to resolve anywhere), without an
+    IPv6 zone id (``%en0`` names an interface of this host, not a LAN peer)."""
+    if "%" in host:
+        return False
+    try:
+        address = ipaddress.ip_address(host)
+    except ValueError:
+        return False
+    return any(address in net for net in LAN_NETWORKS if net.version == address.version)
+
+
+def validate_base_url(base_url: str, *, allow_lan: bool = False) -> str:
+    """Check the G.9.2 / G.6.4 rules on ``base_url`` and return its host (lower case).
+
+    http is allowed on a loopback host, and, with ``allow_lan`` (the CLI's ``--allow-lan-endpoint``, D-698), on a
+    literal private address. Raises :class:`EndpointError` (``endpoint.url.*``). Nothing is fetched or resolved.
+    """
+    if not isinstance(base_url, str) or not base_url or any(ord(c) < 0x21 or ord(c) == 0x7F for c in base_url):
+        raise EndpointError("endpoint.url.malformed", "base URL is empty or contains whitespace or control characters")
+    try:
+        parts = urlsplit(base_url)
+        host = parts.hostname
+        parts.port  # noqa: B018 - raises ValueError on a bad port
+    except ValueError:
+        raise EndpointError("endpoint.url.malformed", "base URL cannot be parsed") from None
+    if parts.scheme not in ("http", "https") or not host:
+        raise EndpointError("endpoint.url.malformed", "base URL needs an http(s) scheme and a host")
+    if parts.username is not None or parts.password is not None or "@" in parts.netloc:
+        raise EndpointError("endpoint.url.userinfo", "base URL must not carry userinfo")
+    if parts.query or "?" in base_url:
+        raise EndpointError("endpoint.url.query", "base URL must not carry a query string")
+    if parts.fragment or "#" in base_url:
+        raise EndpointError("endpoint.url.fragment", "base URL must not carry a fragment")
+    host = host.lower()
+    if parts.scheme != "https" and not is_loopback_host(host) and not (allow_lan and is_private_lan_host(host)):
+        raise EndpointError("endpoint.url.not_https", "base URL must be https unless the host is loopback")
+    return host
+
+
+def check_base_url(endpoint: Endpoint, base_url: str, *, allow_custom: bool = False) -> bool:
+    """Validate a base URL given for ``endpoint`` (e.g. from its ``base_url_env``). Returns True when it is a custom
+    endpoint (its host differs from the registered one), which the caller must record in the manifest.
+
+    The https/loopback/userinfo/query rules always apply. A host mismatch raises ``endpoint.url.host_mismatch``
+    unless ``allow_custom`` (the CLI's ``--allow-custom-endpoint``, R-39).
+    """
+    host = validate_base_url(base_url)
+    if host == endpoint.host:
+        return False
+    if not allow_custom:
+        raise EndpointError("endpoint.url.host_mismatch", f"host does not match the registered host of {endpoint.name!r}")
+    return True
+
+
+def _opt_env(entry: dict[str, Any], key: str, name: str) -> str | None:
+    value = entry.get(key)
+    if value is None:
+        return None
+    if not isinstance(value, str) or not _ENV_NAME.fullmatch(value):
+        raise EndpointError("endpoint.registry.env_name", f"endpoint {name!r}: {key} must be an upper-case variable name")
+    return value
+
+
+def _opt_headers(entry: dict[str, Any], key: str, name: str) -> tuple[str, ...]:
+    value = entry.get(key, [])
+    if not isinstance(value, list) or not all(isinstance(h, str) and _HEADER_NAME.fullmatch(h) for h in value):
+        raise EndpointError("endpoint.registry.header", f"endpoint {name!r}: {key} must be a list of lower-case header names")
+    return tuple(sorted(set(value)))
+
+
+def parse_registry(data: dict[str, Any]) -> dict[str, Endpoint]:
+    """Validate a parsed ``endpoints.toml`` document and return the entries by name, sorted."""
+    if data.get("version") != 1:
+        raise EndpointError("endpoint.registry.version", "unsupported registry version")
+    entries = data.get("endpoints")
+    if not isinstance(entries, dict) or not entries:
+        raise EndpointError("endpoint.registry.empty", "registry has no [endpoints.*] tables")
+    out: dict[str, Endpoint] = {}
+    for name in sorted(entries):
+        entry = entries[name]
+        if not _ENDPOINT_NAME.fullmatch(name) or not isinstance(entry, dict):
+            raise EndpointError("endpoint.registry.name", "bad endpoint name or entry")
+        unknown = set(entry) - _ENTRY_KEYS
+        if unknown:
+            raise EndpointError("endpoint.registry.key", f"endpoint {name!r}: unknown key {sorted(unknown)[0]!r}")
+        base_url = entry.get("base_url")
+        if not isinstance(base_url, str):
+            raise EndpointError("endpoint.registry.base_url", f"endpoint {name!r}: base_url is required")
+        host = validate_base_url(base_url)
+        local = entry.get("local", False)
+        if not isinstance(local, bool):
+            raise EndpointError("endpoint.registry.local", f"endpoint {name!r}: local must be a boolean")
+        if local and not is_loopback_host(host):
+            raise EndpointError("endpoint.registry.local", f"endpoint {name!r}: a local entry must be loopback")
+        api_key_env = _opt_env(entry, "api_key_env", name)
+        if not local and api_key_env is None:
+            raise EndpointError("endpoint.registry.api_key_env", f"endpoint {name!r}: api_key_env is required")
+        server = entry.get("server")
+        if local and (not isinstance(server, str) or server not in LOCAL_SERVERS):
+            raise EndpointError("endpoint.registry.server", f"endpoint {name!r}: a local entry needs server, one of "
+                                f"{sorted(LOCAL_SERVERS)}")
+        if not local and server is not None:
+            raise EndpointError("endpoint.registry.server", f"endpoint {name!r}: server belongs to local entries")
+        conc = entry.get("server_max_concurrency")
+        if conc is not None and (isinstance(conc, bool) or not isinstance(conc, int) or conc < 1):
+            raise EndpointError(
+                "endpoint.registry.concurrency", f"endpoint {name!r}: server_max_concurrency must be an integer >= 1"
+            )
+        api = entry.get("api", API_KINDS[0])
+        if api not in API_KINDS:
+            raise EndpointError("endpoint.registry.api", f"endpoint {name!r}: api must be one of {list(API_KINDS)}")
+        if local and api != API_KINDS[0]:  # every local server kind of D-690 speaks the OpenAI chat wire
+            raise EndpointError("endpoint.registry.local_api", f"endpoint {name!r}: a local entry speaks {API_KINDS[0]}")
+        out[name] = Endpoint(
+            name=name,
+            base_url=base_url,
+            host=host,
+            base_url_env=_opt_env(entry, "base_url_env", name),
+            api_key_env=api_key_env,
+            model_env=_opt_env(entry, "model_env", name),
+            local=local,
+            server_max_concurrency=conc,
+            request_headers=_opt_headers(entry, "request_headers", name),
+            response_headers=_opt_headers(entry, "response_headers", name),
+            api=api,
+            server=server,
+        )
+    return out
+
+
+def load_endpoints() -> dict[str, Endpoint]:
+    """Load and validate the packaged ``endpoints.toml`` (read through ``importlib.resources``)."""
+    raw = resources.files("agentprov_capture").joinpath("endpoints.toml").read_bytes()
+    return parse_registry(tomllib.loads(raw.decode("utf-8")))
+
+
+def get_endpoint(name: str) -> Endpoint:
+    """The registry entry ``name`` (``EndpointError("endpoint.unknown")`` if absent)."""
+    registry = load_endpoints()
+    try:
+        return registry[name]
+    except KeyError:
+        raise EndpointError("endpoint.unknown", f"unknown endpoint shorthand; known: {sorted(registry)}") from None

agentprov_capture-0.1.1/src/agentprov_capture/endpoints.toml

@@ -0,0 +1,156 @@
+# AgentPROV endpoint registry (MN M.1.10 item 2; N.2.1 `--model`; N.2.1a; G.9.2).
+# Data, not code: read through importlib.resources by agentprov_capture.endpoints (no __init__.py needed here).
+#
+# Names only: `base_url_env`, `api_key_env` and `model_env` name environment variables (the .env keys); no value is
+# ever stored here. There are no default model ids (Q5, closed): a model id comes from `--model-id` or `model_env`.
+# `base_url` is the public default. Its host is the registered host that any other base URL must match unless
+# `--allow-custom-endpoint` is given (R-39). A base URL MUST be https, except loopback (127.0.0.1, [::1], localhost),
+# and MUST carry no userinfo, query or fragment (G.6.4).
+#
+# `request_headers` / `response_headers` (optional, lower-case header NAMES) extend the global header allowlist of
+# redact_allowlist.toml for that endpoint (G.6.4: "per-endpoint names declared in endpoints.toml"); the hard denylist
+# wins over them. Only request-id style headers are declared; add a name here, with a test, when a provider needs it.
+#
+# `api` (optional) is the wire format: `openai_chat` (default) or `anthropic_messages` (D-656). It selects the LLM
+# element and the wire recorder's decoding; the CLI sets the agent's provider from it.
+#
+# Baseline set from AgentDojo-PROV `runtime.py` (build_* functions and _LLM_BUILDERS); `omlx` is new (D-10); `lmstudio`,
+# `mlx_lm`, `llamacpp` and `vllm` are new (D-690).
+
+version = 1
+
+[endpoints.deepseek]
+base_url = "https://api.deepseek.com/v1"
+base_url_env = "DEEPSEEK_BASE_URL"
+api_key_env = "DEEPSEEK_API_KEY"
+model_env = "DEEPSEEK_MODEL"
+local = false
+
+[endpoints.openai]
+base_url = "https://api.openai.com/v1"
+base_url_env = "OPENAI_BASE_URL"
+api_key_env = "OPENAI_API_KEY"
+model_env = "OPENAI_MODEL"
+local = false
+response_headers = ["x-request-id", "openai-version"]
+
+# One OpenRouter key and base URL serve openrouter, gemini, llama, qwen and glm (baseline `_build_openrouter_llm`).
+[endpoints.openrouter]
+base_url = "https://openrouter.ai/api/v1"
+base_url_env = "OPENROUTER_BASE_URL"
+api_key_env = "OPENROUTER_API_KEY"
+model_env = "OPENROUTER_MODEL"
+local = false
+response_headers = ["x-request-id"]
+
+[endpoints.gemini]
+base_url = "https://openrouter.ai/api/v1"
+base_url_env = "OPENROUTER_BASE_URL"
+api_key_env = "OPENROUTER_API_KEY"
+model_env = "GEMINI_MODEL"
+local = false
+response_headers = ["x-request-id"]
+
+[endpoints.llama]
+base_url = "https://openrouter.ai/api/v1"
+base_url_env = "OPENROUTER_BASE_URL"
+api_key_env = "OPENROUTER_API_KEY"
+model_env = "LLAMA_MODEL"
+local = false
+response_headers = ["x-request-id"]
+
+[endpoints.qwen]
+base_url = "https://openrouter.ai/api/v1"
+base_url_env = "OPENROUTER_BASE_URL"
+api_key_env = "OPENROUTER_API_KEY"
+model_env = "QWEN_MODEL"
+local = false
+response_headers = ["x-request-id"]
+
+[endpoints.glm]
+base_url = "https://openrouter.ai/api/v1"
+base_url_env = "OPENROUTER_BASE_URL"
+api_key_env = "OPENROUTER_API_KEY"
+model_env = "GLM_MODEL"
+local = false
+response_headers = ["x-request-id"]
+
+# The Anthropic Messages API, direct (D-656). The SDK appends /v1/messages to the base URL. Model ids are the bare API
+# ids (claude-opus-5-5, claude-sonnet-5-5, claude-haiku-5-5, ...), never date-suffixed. Recorded header values: the
+# API version and beta flags sent, and the request id and the two retry headers the SDK's retry decision reads. The
+# organisation id and the rate-limit headers keep their names only; x-api-key is on the hard denylist.
+[endpoints.anthropic]
+base_url = "https://api.anthropic.com"
+base_url_env = "ANTHROPIC_BASE_URL"
+api_key_env = "ANTHROPIC_API_KEY"
+model_env = "ANTHROPIC_MODEL"
+local = false
+api = "anthropic_messages"
+request_headers = ["anthropic-beta", "anthropic-version"]
+response_headers = ["request-id", "retry-after", "x-should-retry"]
+
+# Local OpenAI-compatible servers (N.2.1a; D-690): http on loopback is allowed and no key is needed (an optional
+# `api_key_env` sends one when it is set, D-827). `server` names the server kind; `agentprov models` uses it to
+# fingerprint the server that answers (two kinds share a default port: 8000 omlx/vllm, 8080 mlx_lm/llamacpp) and to
+# read the model identity it exposes. Base URLs are pinned to 127.0.0.1, not `localhost`, which may resolve to ::1.
+# Tool calls: whether a model's replies carry structured `tool_calls` depends on the server, its flags and the model's
+# template; the preflight probe decides (D.10.9 A4), and text-encoded calls need
+# `--allow-text-tool-calls`. `server_max_concurrency` is set only where the server's default is fixed; LM Studio and
+# llama.cpp report their own value, and `--server-max-concurrency` overrides.
+
+# Ollama. Structured tool calls for models whose capabilities include "tools"; others are refused by the server (400).
+# OLLAMA_NUM_PARALLEL depends on the version and memory, and is not reported, so no concurrency default is set.
+[endpoints.ollama]
+base_url = "http://127.0.0.1:11434/v1"
+base_url_env = "LOCAL_LLM_BASE_URL"
+model_env = "LOCAL_MODEL_ID"
+local = true
+server = "ollama"
+
+# oMLX (MLX inference server, Apple Silicon). The model id is the oMLX model directory name or alias (`--model-id`).
+# `server_max_concurrency` is oMLX's `--max-concurrent-requests` default. Structured tool calls through oMLX's parser.
+# `api_key_env` is optional on a local entry (D-827): oMLX can be set up with an API key. When `OMLX_API_KEY` is set
+# (keychain first, then .env), it is sent as a bearer header to the loopback server, and never to a LAN address; when
+# it is not set, no key is sent, as for every other local server. `model_env` (D-827 addendum): `OMLX_MODEL` in .env
+# names the served model id (oMLX's own id, e.g. its folder name, not a Hugging Face repo id) when `--model-id` is not
+# given; without either, a terminal offers a pick.
+[endpoints.omlx]
+base_url = "http://127.0.0.1:8000/v1"
+base_url_env = "OMLX_BASE_URL"
+api_key_env = "OMLX_API_KEY"
+model_env = "OMLX_MODEL"
+local = true
+server = "omlx"
+server_max_concurrency = 8
+
+# LM Studio's server (`lms server start`). Native tool calls for models with `trained_for_tool_use`; for other models LM
+# Studio adds its own tool-use system prompt on the server (invisible to the wire capture), which `run` refuses unless
+# `--allow-text-tool-calls`. The parallel-request limit is read from the loaded instance (`/api/v1/models`).
+[endpoints.lmstudio]
+base_url = "http://127.0.0.1:1234/v1"
+base_url_env = "LMSTUDIO_BASE_URL"
+local = true
+server = "lmstudio"
+
+# mlx_lm.server (MLX LM). The model id is a Hugging Face repo id or a local path. Requests are served one at a time by
+# default. Tool calls depend on the mlx-lm version and the model's chat template; text-encoded calls are common.
+[endpoints.mlx_lm]
+base_url = "http://127.0.0.1:8080/v1"
+base_url_env = "MLX_LM_BASE_URL"
+local = true
+server = "mlx_lm"
+server_max_concurrency = 1
+
+# llama.cpp `llama-server`. Structured tool calls only when started with `--jinja`; the slot count is read from /props.
+[endpoints.llamacpp]
+base_url = "http://127.0.0.1:8080/v1"
+base_url_env = "LLAMACPP_BASE_URL"
+local = true
+server = "llamacpp"
+
+# vLLM's OpenAI-compatible server. Structured tool calls only with `--enable-auto-tool-choice --tool-call-parser <p>`.
+[endpoints.vllm]
+base_url = "http://127.0.0.1:8000/v1"
+base_url_env = "VLLM_BASE_URL"
+local = true
+server = "vllm"