Vet ops provider_tables and resolve_openai_chat_model; pin the contract at dd3d3be

provider_tables serializes the reference's provider tables, published by
lm15-contract as tables/providers.json for the ports to generate theirs
from. resolve_openai_chat_model drives the contract's litellm-prefix
router cases.

Signed-off-by: Maxime Rivest <mrive052@gmail.com>

Author: MaximeRivest

CONTRACT_PIN

@@ -1 +1 @@
-57e33d17f562f932df920e6c6e876d9d8799c53b
+dd3d3bec9f3411c332ae934d4b934e66437e1846

lm15/_vet_tables.py

@@ -0,0 +1,105 @@
+"""The provider tables, as data, for the vet protocol's ``provider_tables`` op.
+
+``lm15-contract/tables/providers.json`` is this function's output, and
+``tools/audit.py`` there fails when the two differ. Ports generate their
+copies from that file (``playbooks/port.md`` rule 2: tables are data, copied,
+never re-derived). This module reads the tables the reference uses at import
+time and serializes them; it adds no fact of its own.
+
+Shape rules, so a generator never guesses:
+
+- Compat policies list only the knobs a preset sets (``None`` means
+  "inherit", so an absent key is exactly the value), with
+  ``model_overrides`` as ``[prefix, {knob: value}]`` pairs in match order.
+- Access policies, host specs and endpoint support are written whole, every
+  field, so a port never depends on its own defaults agreeing with these.
+- Tuples become arrays and keep their order; mappings keep insertion order;
+  a frozenset (``EndpointSupport.extra``) becomes a sorted array.
+- Field names are the reference's (snake_case); a port renames them.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Mapping
+from typing import Any
+
+SCHEMA = 1
+
+
+_NO_DEFAULT = object()
+
+
+def _default(f: dataclasses.Field) -> Any:
+    if f.default is not dataclasses.MISSING:
+        return f.default
+    if f.default_factory is not dataclasses.MISSING:  # type: ignore[misc]
+        return f.default_factory()  # type: ignore[misc]
+    return _NO_DEFAULT
+
+
+def _plain(value: Any, *, elide: tuple[type, ...]) -> Any:
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        out: dict[str, Any] = {}
+        for f in dataclasses.fields(value):
+            v = getattr(value, f.name)
+            if isinstance(value, elide) and v == _default(f):
+                continue  # a compat knob at its default inherits
+            out[f.name] = _plain(v, elide=elide)
+        return out
+    if isinstance(value, Mapping):
+        return {str(k): _plain(v, elide=elide) for k, v in value.items()}
+    if isinstance(value, (frozenset, set)):
+        return sorted(_plain(v, elide=elide) for v in value)
+    if isinstance(value, (list, tuple)):
+        return [_plain(v, elide=elide) for v in value]
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    raise TypeError(f"provider_tables: no JSON form for {type(value).__name__}")
+
+
+def provider_tables() -> dict[str, Any]:
+    from . import compat as _compat
+    from .login import declared as _declared
+    from .login import flows as _flows
+    from . import registry as _registry
+    from . import router as _router
+
+    elide = (_compat.OpenAIChatCompat, _compat.OpenAIResponsesCompat, _compat.AnthropicCompat)
+
+    def plain(value: Any) -> Any:
+        return _plain(value, elide=elide)
+
+    def row(definition: Any) -> dict[str, Any]:
+        compat = definition.compat
+        return {
+            "id": definition.id,
+            "dialect": definition.dialect,
+            "kind": "hosted" if definition.hosted else ("bound" if definition.bound else "adapter-owned"),
+            "compat": compat if compat is None or isinstance(compat, str) else plain(compat),
+            "access": plain(definition.access),
+            "aliases": list(definition.aliases),
+            "placeholder_key": definition.placeholder_key,
+            "console_url": definition.console_url,
+            "note": definition.note,
+        }
+
+    return {
+        "schema": SCHEMA,
+        "providers": [row(d) for d in _registry.PROVIDERS.values()],
+        "declared_login": [row(d) for d in _declared.DECLARED_PROVIDERS],
+        "compat": {
+            "chat": plain(_compat.OPENAI_CHAT_PRESETS),
+            "chat_base_urls": plain(_compat.OPENAI_CHAT_PRESET_BASE_URLS),
+            "responses": plain(_compat.OPENAI_RESPONSES_PRESETS),
+            "responses_base_urls": plain(_compat.OPENAI_RESPONSES_PRESET_BASE_URLS),
+            "anthropic": plain(_compat.ANTHROPIC_PRESETS),
+            "anthropic_base_urls": plain(_compat.ANTHROPIC_PRESET_BASE_URLS),
+            "preset_aliases": plain(_compat._OPENAI_CHAT_PRESET_ALIASES),
+        },
+        "routing": {
+            "default_rules": [{"prefix": r.prefix, "provider": r.provider, "note": r.note} for r in _router.DEFAULT_RULES],
+            "litellm_prefixes": plain(_router.LITELLM_PROVIDER_PREFIXES),
+        },
+        "login": {"service_labels": plain(_flows._SERVICE_LABELS)},
+    }

lm15/vet.py

@@ -349,6 +349,25 @@ def op_resolve_model(msg: JsonObject) -> JsonObject:
     return {"provider": resolution.provider, "model": resolution.model, "source": resolution.source}
 
 
+def op_resolve_openai_chat_model(msg: JsonObject) -> JsonObject:
+    """PROTOCOL.md resolve_openai_chat_model: the router's
+    ``resolve_openai_chat`` (the OpenAI SDK and litellm spellings, read by
+    ``openai_chat_model_string``) over harness-supplied inputs only."""
+    from .router import LMRouter, RouterConfig
+
+    env = {str(k): str(v) for k, v in (msg.get("env") or {}).items()}
+    resolution = LMRouter(RouterConfig(env=env)).resolve_openai_chat(str(msg["model"]))
+    return {"provider": resolution.provider, "model": resolution.model, "source": resolution.source}
+
+
+def op_provider_tables(msg: JsonObject) -> JsonObject:
+    """PROTOCOL.md provider_tables (reference only): the registry, access
+    policies, compat presets and router tables, as data."""
+    from ._vet_tables import provider_tables
+
+    return provider_tables()
+
+
 def op_build_models_request(msg: JsonObject) -> JsonObject:
     lm = _adapter(msg)
     return normalize_transport_request(lm._models_request())
@@ -812,6 +831,8 @@ def _string_vocabulary(obj: Any) -> list[str] | None:
     "surface_dump": op_surface_dump,
     "explain_auth": op_explain_auth,
     "resolve_model": op_resolve_model,
+    "resolve_openai_chat_model": op_resolve_openai_chat_model,
+    "provider_tables": op_provider_tables,
     "token_exchange_build": op_token_exchange_build,
     "token_exchange_parse": op_token_exchange_parse,
     "sigv4_sign": op_sigv4_sign,

tests/test_vet_shim.py

@@ -40,9 +40,11 @@
     "normalize_error",
     "parse_models_response",
     "parse_response",
+    "provider_tables",
     "replay_live",
     "replay_stream",
     "resolve_model",
+    "resolve_openai_chat_model",
     "serde_roundtrip",
     "sigv4_sign",
     "surface_dump",

tests/test_vet_tables.py

@@ -0,0 +1,53 @@
+"""The vet shim's provider_tables and resolve_openai_chat_model ops.
+
+provider_tables is what lm15-contract publishes as tables/providers.json and
+what the TypeScript, Rust and Go ports generate their tables from, so it must
+be exact JSON of the tables the reference itself uses.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from lm15 import compat, registry, router
+from lm15.errors import UnknownModelError
+from lm15.vet import op_provider_tables, op_resolve_openai_chat_model
+
+
+def test_tables_are_json_and_mirror_the_registry() -> None:
+    tables = op_provider_tables({})
+    assert json.loads(json.dumps(tables)) == tables  # JSON values only, nothing lost
+    assert tables["schema"] == 1
+    assert [row["id"] for row in tables["providers"]] == list(registry.PROVIDERS)
+    for row in tables["providers"]:
+        definition = registry.PROVIDERS[row["id"]]
+        assert row["access"]["provider"] == definition.access.provider
+        assert row["access"]["env_keys"] == list(definition.access.env_keys)
+        assert row["kind"] == ("hosted" if definition.hosted else "bound" if definition.bound else "adapter-owned")
+        assert row["note"] == definition.note
+
+
+def test_compat_presets_list_only_the_knobs_they_set() -> None:
+    tables = op_provider_tables({})
+    assert set(tables["compat"]["chat"]) == set(compat.OPENAI_CHAT_PRESETS)
+    deepinfra = tables["compat"]["chat"]["deepinfra"]
+    assert "routing" not in deepinfra  # unset knobs inherit and are absent
+    prefix, knobs = deepinfra["model_overrides"][0]
+    assert isinstance(prefix, str) and isinstance(knobs, dict)
+    assert tables["compat"]["anthropic"]["anthropic"] == {}
+
+
+def test_router_tables_in_match_order() -> None:
+    tables = op_provider_tables({})
+    assert [r["prefix"] for r in tables["routing"]["default_rules"]] == [r.prefix for r in router.DEFAULT_RULES]
+    assert tables["routing"]["litellm_prefixes"] == dict(router.LITELLM_PROVIDER_PREFIXES)
+
+
+def test_resolve_openai_chat_model_reads_litellm_spellings() -> None:
+    assert op_resolve_openai_chat_model({"model": "groq/openai/gpt-oss-20b", "env": {}}) == {
+        "provider": "groq", "model": "openai/gpt-oss-20b", "source": "prefix"}
+    assert op_resolve_openai_chat_model({"model": "gpt-4.1-mini", "env": {}})["provider"] == "openai-chat"
+    with pytest.raises(UnknownModelError):
+        op_resolve_openai_chat_model({"model": "bedrock/anthropic.claude-sonnet-5", "env": {}})