swarph-cli 0.72.19__tar.gz → 0.72.20__tar.gz

{swarph_cli-0.72.19/src/swarph_cli.egg-info → swarph_cli-0.72.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.19
+Version: 0.72.20
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.19 → swarph_cli-0.72.20}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.19"
+version = "0.72.20"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.72.19 → swarph_cli-0.72.20}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.72.19"
+__version__ = "0.72.20"
 
 __all__ = ["__version__"]

{swarph_cli-0.72.19 → swarph_cli-0.72.20}/src/swarph_cli/bench/providers.py

@@ -99,3 +99,23 @@ def load_registry(path: str | Path | None) -> dict[str, dict]:
     raw = Path(path).read_text(encoding="utf-8")
     data = tomllib.loads(raw)
     return {name: _check(name, entry) for name, entry in data.items()}
+
+
+def provider_arm(name: str, entry: dict, noul_threshold):
+    """The registry arm for ``provider:<name>``.
+
+    ``kind = "decisions"`` is the OpenAI Decisions translator. ``typed`` and
+    ``semantic`` stay on :class:`~swarph_cli.bench.backends.HttpBackend`,
+    which posts a typed pack body unchanged.
+    """
+    from .backends import DecisionsBackend, HttpBackend
+
+    common = dict(
+        name=name, base_url=entry["base_url"], path=entry["path"],
+        auth=entry.get("auth"), usage=entry.get("usage"),
+        price=entry.get("price"), egress=entry["egress"],
+        noul_threshold=noul_threshold,
+    )
+    if entry["kind"] == "decisions":
+        return DecisionsBackend(**common)
+    return HttpBackend(kind=entry["kind"], **common)

{swarph_cli-0.72.19 → swarph_cli-0.72.20}/src/swarph_cli/bench/validate.py

@@ -22,7 +22,7 @@ import json
 from .backends import Backend
 from .pack import validate_schema
 from .quality import d_text
-from .runner import ModelSpec, preflight, run_pack
+from .runner import ModelSpec, parse_models, preflight, run_pack
 
 DISCRIMINATION_MIN_SPREAD = 0.05  # min stdev of mean_distance across reference models
 # Conservative: text prompts and their expected answers naturally share topical
@@ -199,13 +199,48 @@ CALIBRATION_NOTICE = (
 )
 
 
-def gate_calibration(pack: dict, backends: Optional[dict[str, Backend]] = None) -> list[str]:
+def _calibration_spec(model: str, pack: dict, registry: Optional[dict]):
+    """One spec from the same grammar ``--models`` uses.
+
+    ``provider:<name>`` is not runnable until its registry arm is attached.
+    A bare id stays on the metered default, which is what ``parse_models``
+    already does — this does not reimplement that split.
+    """
+    from .providers import RegistryError, load_registry, provider_arm, registry_path
+
+    specs = parse_models(model)
+    if len(specs) != 1:
+        return None
+    spec = specs[0]
+    if spec.backend != "provider":
+        return spec
+    try:
+        if registry is None:
+            registry = load_registry(registry_path())
+    except (OSError, RegistryError) as exc:
+        raise RegistryError(str(exc)) from exc
+    entry = (registry or {}).get(spec.provider)
+    if entry is not None:
+        spec.arm = provider_arm(spec.provider, entry, pack.get("noul_threshold"))
+    return spec
+
+
+def gate_calibration(
+    pack: dict,
+    backends: Optional[dict[str, Backend]] = None,
+    *,
+    registry: Optional[dict] = None,
+) -> list[str]:
     """ALWAYS emits the context-calibration requirement as a warning (§5d is
     guidance, not automatable in full). If the pack declares
     ``meta.calibration`` ({model, task_ids, expected_mean_distance_max}),
     additionally checks that the declared model+system reproduces it — full
     standardization of this format is DEFERRED (decision #4); this is the
-    minimal v1 check."""
+    minimal v1 check.
+
+    ``meta.calibration.model`` is one ``parse_models`` token: ``id[:backend[:label]]``
+    or ``provider:<name>``. A bare id keeps the metered backend.
+    """
     warnings = [CALIBRATION_NOTICE]
     calib = (pack.get("meta") or {}).get("calibration")
     if not calib:
@@ -214,7 +249,7 @@ def gate_calibration(pack: dict, backends: Optional[dict[str, Backend]] = None)
     model = calib.get("model")
     task_ids = calib.get("task_ids")
     expected_max = calib.get("expected_mean_distance_max")
-    if not (model and task_ids and expected_max is not None):
+    if not (isinstance(model, str) and model.strip() and task_ids and expected_max is not None):
         warnings.append(
             "meta.calibration is present but malformed (need model, task_ids, "
             "expected_mean_distance_max) — skipping the reproduction check"
@@ -229,10 +264,26 @@ def gate_calibration(pack: dict, backends: Optional[dict[str, Backend]] = None)
         )
         return warnings
 
-    runnable, preflight_warnings = preflight([ModelSpec(id=model)], backends)
+    from .providers import RegistryError
+
+    try:
+        spec = _calibration_spec(model, pack, registry)
+    except RegistryError as exc:
+        warnings.append(f"meta.calibration provider registry unreadable: {exc}")
+        return warnings
+    if spec is None:
+        warnings.append(
+            f"meta.calibration model={model!r} must be one model spec "
+            f"(id[:backend[:label]] or provider:<name>) — skipping the reproduction check"
+        )
+        return warnings
+
+    runnable, preflight_warnings = preflight([spec], backends, pack=pack)
     warnings.extend(preflight_warnings)
     if not runnable:
-        warnings.append(f"meta.calibration check could not run: {model!r} lacks credentials")
+        # The preflight warning already names the refusal (credentials, kind
+        # mismatch, on_box_only egress). A second "lacks credentials" line
+        # mislabels every other refusal as a missing key.
         return warnings
 
     result = run_pack(runnable, pack, backends, task_ids=task_ids)

{swarph_cli-0.72.19 → swarph_cli-0.72.20}/src/swarph_cli/commands/bench.py

@@ -32,7 +32,6 @@ from swarph_cli.bench.backends import (
     SubscriptionBackend,
     TypedHttpBackend,
     HttpBackend,
-    DecisionsBackend,
 )
 from swarph_cli.bench.pack import PackError, load_pack, slugify_theme, validate_schema
 from swarph_cli.bench.providers import RegistryError, load_registry, registry_path
@@ -223,21 +222,9 @@ def _default_packs_dir() -> Path:
 
 
 def _provider_arm(name: str, entry: dict, noul_threshold):
-    """The registry arm for ``provider:<name>``.
-
-    ``kind = "decisions"`` is the OpenAI Decisions translator. ``typed`` and
-    ``semantic`` stay on :class:`HttpBackend`, which posts a typed pack body
-    unchanged.
-    """
-    common = dict(
-        name=name, base_url=entry["base_url"], path=entry["path"],
-        auth=entry.get("auth"), usage=entry.get("usage"),
-        price=entry.get("price"), egress=entry["egress"],
-        noul_threshold=noul_threshold,
-    )
-    if entry["kind"] == "decisions":
-        return DecisionsBackend(**common)
-    return HttpBackend(kind=entry["kind"], **common)
+    """The registry arm for ``provider:<name>``. Same constructor validate uses."""
+    from swarph_cli.bench.providers import provider_arm
+    return provider_arm(name, entry, noul_threshold)
 
 
 # ── dispatch ───────────────────────────────────────────────────────────────

{swarph_cli-0.72.19 → swarph_cli-0.72.20/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.19
+Version: 0.72.20
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.19 → swarph_cli-0.72.20}/tests/test_bench_validate.py

@@ -294,7 +294,147 @@ def test_calibration_missing_creds_flagged_gracefully():
             return ["SOME_KEY"]
 
     warnings = gate_calibration(p, backends={"metered": NoCreds()})
-    assert any("lacks credentials" in w for w in warnings)
+    assert any("requires SOME_KEY" in w and "skipped" in w for w in warnings)
+    assert not any("lacks credentials" in w for w in warnings)
+
+
+class _Recording:
+    def __init__(self, inner):
+        self.inner = inner
+        self.calls = []
+
+    def generate(self, model_id, prompt, system=""):
+        self.calls.append(model_id)
+        return self.inner.generate(model_id, prompt, system)
+
+    def missing_creds(self):
+        return []
+
+
+def test_calibration_subscription_backend_is_called():
+    p = _pack(meta={"calibration": {
+        "model": "m:subscription",
+        "task_ids": ["arith_mult"],
+        "expected_mean_distance_max": 0.1,
+    }})
+    subscription = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    metered = _Recording(ScriptedBackend({}))
+    warnings = gate_calibration(p, backends={"subscription": subscription, "metered": metered})
+    assert subscription.calls == ["m"]
+    assert metered.calls == []
+    assert any("meta.calibration OK" in w or "MISMATCH" in w for w in warnings)
+    assert not any("could not run" in w for w in warnings)
+
+
+def test_calibration_bare_id_binds_metered_backend():
+    p = _pack(meta={"calibration": {
+        "model": "bare-id",
+        "task_ids": ["arith_mult"],
+        "expected_mean_distance_max": 0.1,
+    }})
+    subscription = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    metered = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    warnings = gate_calibration(p, backends={"subscription": subscription, "metered": metered})
+    assert metered.calls == ["bare-id"]
+    assert subscription.calls == []
+    assert any("meta.calibration OK" in w for w in warnings)
+
+
+def test_calibration_provider_resolves_registry_arm(monkeypatch):
+    from swarph_cli.bench import providers as providers_mod
+    from swarph_cli.bench.backends import HttpBackend
+
+    built = []
+    seen = []
+    real = providers_mod.provider_arm
+
+    def wrapped(name, entry, noul):
+        arm = real(name, entry, noul)
+        built.append((name, entry, arm))
+        inner = ScriptedBackend(PERFECT_ANSWERS)
+
+        def generate(model_id, prompt, system=""):
+            seen.append(model_id)
+            return inner.generate(model_id, prompt, system)
+
+        arm.generate = generate
+        return arm
+
+    monkeypatch.setattr(providers_mod, "provider_arm", wrapped)
+    entry = {
+        "kind": "typed",
+        "base_url": "http://127.0.0.1:9",
+        "path": "/v1/systemone",
+        "egress": "local",
+    }
+    p = _pack(meta={"calibration": {
+        "model": "provider:openai",
+        "task_ids": ["arith_mult"],
+        "expected_mean_distance_max": 0.1,
+    }})
+    metered = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    warnings = gate_calibration(
+        p, backends={"metered": metered}, registry={"openai": entry},
+    )
+    assert built and built[0][0] == "openai" and built[0][1] is entry
+    assert isinstance(built[0][2], HttpBackend)
+    assert seen == ["openai"]
+    assert metered.calls == []
+    assert any("meta.calibration OK" in w or "MISMATCH" in w for w in warnings)
+    assert not any("could not run" in w for w in warnings)
+
+
+def test_calibration_on_box_only_refuses_external_provider(monkeypatch):
+    from swarph_cli.bench import providers as providers_mod
+
+    calls = []
+    real = providers_mod.provider_arm
+
+    def wrapped(name, entry, noul):
+        arm = real(name, entry, noul)
+
+        def generate(model_id, prompt, system=""):
+            calls.append(model_id)
+            raise AssertionError("external arm must not be dispatched")
+
+        arm.generate = generate
+        return arm
+
+    monkeypatch.setattr(providers_mod, "provider_arm", wrapped)
+    entry = {
+        "kind": "typed",
+        "base_url": "https://api.example.com",
+        "path": "/v1/systemone",
+        "egress": "external",
+    }
+    p = _pack(
+        egress="on_box_only",
+        meta={"calibration": {
+            "model": "provider:openai",
+            "task_ids": ["arith_mult"],
+            "expected_mean_distance_max": 0.1,
+        }},
+    )
+    warnings = gate_calibration(p, backends={}, registry={"openai": entry})
+    assert calls == []
+    assert any("on_box_only" in w and "external" in w for w in warnings)
+    assert not any("lacks credentials" in w for w in warnings)
+
+
+def test_calibration_kind_mismatch_refuses_the_arm():
+    p = _pack(
+        request_kind="typed",
+        meta={"calibration": {
+            "model": "m:subscription",
+            "task_ids": ["arith_mult"],
+            "expected_mean_distance_max": 0.1,
+        }},
+    )
+    subscription = _Recording(ScriptedBackend(PERFECT_ANSWERS))
+    warnings = gate_calibration(p, backends={"subscription": subscription})
+    assert subscription.calls == []
+    assert any("kind mismatch: pack=typed arm=semantic" in w for w in warnings)
+    assert not any("lacks credentials" in w for w in warnings)
 
 
 # ── orchestration: validate_pack ───────────────────────────────────────────