cmpnd 0.44.0__tar.gz → 0.45.0__tar.gz

{cmpnd-0.44.0 → cmpnd-0.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.44.0
+Version: 0.45.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

{cmpnd-0.44.0 → cmpnd-0.45.0}/cmpnd/__init__.py

@@ -46,7 +46,7 @@ from .deployment_runs import (
 )
 from .execution import DeployedProgram, RetryableProviderError, deployment_run_id, execute
 from .exporter import flush_exporter, shutdown_exporter
-from .lm_configuration import configure_lm
+from .lm_configuration import SystemOne, configure_lm
 from .mcp_servers import (
     Bearer,
     McpToolReference,
@@ -80,6 +80,7 @@ __all__ = [
     # Configuration
     "configure",
     "configure_lm",
+    "SystemOne",
     "get_config",
     "require_config",
     # Main callback

{cmpnd-0.44.0 → cmpnd-0.45.0}/cmpnd/callback.py

@@ -383,6 +383,10 @@ def _lm15_cache_hit(entry: Any, response: Any) -> bool | None:
 
 def _usage_dialect(instance: Any, usage: Any) -> str | None:
     """Name the response surface only when its shape establishes one."""
+    # A decision client (DSPy's `TypeSafe`) speaks System One. Its usage names chat's token
+    # fields, so the shape alone would misname it. DSPy dispatches on the same flag.
+    if getattr(instance, "supports_decision_requests", False) is True:
+        return "system_one"
     model_type = _text_field(instance, "model_type")
     if model_type == "responses":
         return "responses"
@@ -1489,7 +1493,8 @@ class _LMMixin(_CallbackBase):
             observation.usage_dialect = _usage_dialect(instance, usage)
             if observation.usage_dialect in {"chat_completions", "responses"}:
                 observation.prompt_inclusion = "includes_cache_reads"
-            elif observation.usage_dialect == "converse":
+            elif observation.usage_dialect in {"converse", "system_one"}:
+                # System One serves nothing from a cache, so its prompt is all fresh input.
                 observation.prompt_inclusion = "excludes_cache_reads"
 
             if usage_reported and usage is not None:

{cmpnd-0.44.0 → cmpnd-0.45.0}/cmpnd/lm_configuration.py

@@ -9,11 +9,25 @@ class LMConfigurationError(ValueError):
     """A hosted binding declaration cannot be resolved consistently."""
 
 
-class LMCapabilities(TypedDict):
-    """Explicit adapter hints for a hosted model, independent of its provider."""
+class LMCapabilities(TypedDict, total=False):
+    """Explicit adapter hints for a hosted model, independent of its provider.
+
+    ``dialect`` is present only for a System One binding, which :class:`SystemOne`
+    writes. Absent, the binding is a chat model.
+    """
 
     supported_params: list[str]
     supports_response_schema: bool
+    dialect: str
+
+
+# The wire protocol a binding's model speaks, named for the protocol and never for a
+# provider or a client library: a chat model answers chat completions, and a System One
+# model (TypeSafe's System One protocol, which other providers serve too) answers a set
+# of questions about a state.
+CHAT_COMPLETIONS = "chat_completions"
+SYSTEM_ONE = "system_one"
+_DIALECTS = frozenset({CHAT_COMPLETIONS, SYSTEM_ONE})
 
 
 def _validate_lm_capabilities(value: object) -> dict[str, LMCapabilities]:
@@ -27,7 +41,7 @@ def _validate_lm_capabilities(value: object) -> dict[str, LMCapabilities]:
             )
         if not isinstance(declaration, dict):
             raise LMConfigurationError(f"lm_capabilities[{binding!r}] must be a capability declaration")
-        unknown = declaration.keys() - {"supported_params", "supports_response_schema"}
+        unknown = declaration.keys() - {"supported_params", "supports_response_schema", "dialect"}
         if unknown:
             raise LMConfigurationError(f"lm_capabilities[{binding!r}] has unknown fields: {sorted(unknown, key=str)}")
         params = declaration.get("supported_params", [])
@@ -38,11 +52,24 @@ def _validate_lm_capabilities(value: object) -> dict[str, LMCapabilities]:
         schema = declaration.get("supports_response_schema", False)
         if not isinstance(schema, bool):
             raise LMConfigurationError(f"lm_capabilities[{binding!r}].supports_response_schema must be a boolean")
+        dialect = declaration.get("dialect", CHAT_COMPLETIONS)
+        if dialect not in _DIALECTS:
+            raise LMConfigurationError(
+                f"lm_capabilities[{binding!r}].dialect must be one of {sorted(_DIALECTS)} (got {dialect!r})"
+            )
+        if dialect == SYSTEM_ONE and (params or schema):
+            raise LMConfigurationError(
+                f"lm_capabilities[{binding!r}] is a System One binding, which takes no sampling "
+                "parameters and no response schema"
+            )
         if schema and "response_format" not in params:
             raise LMConfigurationError(
                 f"lm_capabilities[{binding!r}] requires response_format in supported_params for schema output"
             )
-        result[binding] = {"supported_params": list(dict.fromkeys(params)), "supports_response_schema": schema}
+        hints: LMCapabilities = {"supported_params": list(dict.fromkeys(params)), "supports_response_schema": schema}
+        if dialect == SYSTEM_ONE:
+            hints["dialect"] = SYSTEM_ONE
+        result[binding] = hints
     return result
 
 
@@ -122,6 +149,11 @@ def configure_lm(
             )
         _merge(_names, _name(lm), hints)
         return
+    _declare(lm, hints)
+
+
+def _declare(lm: Any, hints: dict[str, Any]) -> None:
+    """Attach a declaration to one LM object, shared by every binding made from it."""
     model = _model(lm)
     declared = _object_declaration(lm)
     if declared is not None and declared != (model, hints):
@@ -131,6 +163,38 @@ def configure_lm(
         _objects.append(lm)
 
 
+class SystemOne:
+    """A System One decision model, for a run's ``lms``.
+
+    A System One model answers a set of questions about a state instead of continuing a
+    conversation: TypeSafe's Jev, or another endpoint serving the same schema. A hosted
+    judge built on ``dspy.experimental.TypeSafe`` runs against the run's System One
+    binding without naming a key or a URL::
+
+        cmpnd.optimize(..., lms={"judge": cmpnd.SystemOne("typesafe/jev-latest")})
+
+    ``model`` is a platform model id: the prefix names the organization's sealed
+    credential, and the rest is the model at that credential's endpoint. Writing the
+    binding this way is the only thing that makes it a System One binding; a model name
+    on its own never does.
+    """
+
+    def __init__(self, model: object):
+        if not isinstance(model, str) or not model.strip():
+            raise ValueError(f"cmpnd.SystemOne needs a model id such as 'typesafe/jev-latest' (got {model!r})")
+        credential, _, name = model.strip().partition("/")
+        if not credential or not name:
+            raise ValueError(
+                f"cmpnd.SystemOne({model!r}) names no credential: write the model as "
+                "'<credential>/<model>', for example 'typesafe/jev-latest'"
+            )
+        self.model = model.strip()
+        _declare(self, {"supported_params": [], "supports_response_schema": False, "dialect": SYSTEM_ONE})
+
+    def __repr__(self) -> str:
+        return f"cmpnd.SystemOne({self.model!r})"
+
+
 def restore(declarations: object) -> None:
     """Load model-pinned declarations from a packaged artifact."""
     if not isinstance(declarations, dict):

{cmpnd-0.44.0 → cmpnd-0.45.0}/cmpnd/optimization.py

@@ -462,6 +462,23 @@ def _lms_config(config: dict[str, Any], lms: Any) -> None:
         if isinstance(lm, str):
             declared[name] = {"model": lm}
             continue
+        from .lm_configuration import SystemOne
+
+        if isinstance(lm, SystemOne):
+            # A System One model takes no sampling, and its declaration (which says it
+            # is one) travels in the bundle rather than on the wire.
+            declared[name] = {"model": lm.model}
+            continue
+        if getattr(lm, "supports_decision_requests", False):
+            # dspy.experimental.TypeSafe, or a client like it: it carries a key and a URL
+            # rather than the name of a sealed credential, so the platform has nothing to
+            # resolve. Duck-typed so this module never imports dspy at scope.
+            raise ValueError(
+                f"{subject} is a {type(lm).__name__} client, which names a key and a URL rather "
+                f"than a credential. Bind the model with cmpnd.SystemOne, for example "
+                f"lms={{{name!r}: cmpnd.SystemOne('typesafe/jev-latest')}}; a judge that builds "
+                f"its own {type(lm).__name__} runs against that binding when hosted"
+            )
         model = _lm_model(lm, subject)
         _refuse_credential_on(lm, model, subject)
         entry: dict[str, Any] = {"model": model}

{cmpnd-0.44.0 → cmpnd-0.45.0}/docs/sdk-instrumentation.md

@@ -73,6 +73,27 @@ endpoint accept JSON schemas. Undeclared bindings keep prompt-only JSON. These
 hints do not add a format the provider cannot accept or change local DSPy's
 capability lookup.
 
+### System One judges
+
+A System One model answers a set of questions about a state instead of continuing
+a conversation. TypeSafe's Jev is one, and other endpoints serve the same schema.
+Declare one for a run with `cmpnd.SystemOne`:
+
+```python
+cmpnd.optimize(..., lms={"judge": cmpnd.SystemOne("typesafe/jev-latest")})
+```
+
+The prefix names the organization's sealed credential and the rest names the
+model at that credential's endpoint. Writing the binding this way is the only
+thing that makes it a System One binding; a model name never does. The binding
+carries no sampling, and its declaration travels in the bundle like any other.
+
+Hosted, a judge built on `dspy.experimental.TypeSafe` runs unchanged. The kernel
+replaces `TypeSafe` with a client that spends the run's System One binding, so
+the judge's own model, key and base URL are not used. With several System One
+bindings, the judge picks one through `lms[name]`. A `TypeSafe` object passed in
+`lms` is refused, because it names a key and a URL rather than a credential.
+
 ## The callback
 
 `python-sdk/cmpnd/callback.py` implements `CmpndCallback`, which satisfies `dspy.utils.callback.BaseCallback` without inheriting it — `callback.py` must import on the standard library alone (`tests/test_import_weight.py`), so it cannot import dspy to get a base class. DSPy calls its hook methods synchronously on whatever thread is executing the module. The callback owns no long-lived state beyond a per-call span builder map; everything trace/span related flows through context vars (see next section).

{cmpnd-0.44.0 → cmpnd-0.45.0}/pyproject.toml

@@ -5,7 +5,7 @@ name = "cmpnd"
 # it's new) — no git tags. Bump with `uv version --bump {minor,patch}` or by
 # hand. Runtime `cmpnd.__version__` reads installed metadata, so it tracks
 # this automatically. See docs/plans/2026-07-02-sdk-pypi-tag-free-publish.md.
-version = "0.44.0"
+version = "0.45.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.44.0 → cmpnd-0.45.0}/tests/integration/hosted_optimize_probe.py

@@ -199,6 +199,48 @@ def feedback_metric(gold, pred, trace=None, pred_name=None, pred_trace=None, lms
     return dspy.Prediction(score=0.0, feedback=f"answered nothing; the expected answer is {want!r}{verdict}")
 
 
+def system_one_metric(gold, pred, trace=None, pred_name=None, pred_trace=None, lms=None):
+    """:func:`feedback_metric`, judging the way a System One judge written for a laptop does.
+
+    The judge builds its own ``TypeSafe`` with a model name and no binding. Hosted, the
+    kernel replaces that client with one that spends the run's System One binding, which
+    the run declares with ``cmpnd.SystemOne``. The verdict goes into the feedback and never
+    into the score, for :func:`feedback_metric`'s reason.
+
+    ``dspy.experimental`` needs DSPy 3.4, which the kernel runs and this client may not, so
+    the judge's imports are inside the branch that only a hosted run reaches.
+    """
+    import dspy
+
+    got = str(getattr(pred, "answer", "") or "").strip().lower()
+    want = str(getattr(gold, "answer", "") or "").strip().lower()
+
+    verdict = ""
+    if lms is not None:
+        from dspy.experimental import Noul, TypeSafe
+
+        class Right(dspy.Signature):
+            """Decide whether the answer is right."""
+
+            question: str = dspy.InputField()
+            answer: str = dspy.InputField()
+            right: Noul = dspy.OutputField(desc="is the answer right")
+
+        judge = dspy.Predict(Right)
+        judge.lm = TypeSafe("jev-latest")
+        judged = judge(question=str(getattr(gold, "question", "")), answer=got)
+        verdict = f" (the judge put {judged.right.probability:.2f} on right)"
+
+    if got == want:
+        return dspy.Prediction(score=1.0, feedback=f"exactly right{verdict}")
+    if got:
+        return dspy.Prediction(
+            score=0.25,
+            feedback=(f"answered {got!r} but the expected answer is {want!r}; answer in one lowercase word{verdict}"),
+        )
+    return dspy.Prediction(score=0.0, feedback=f"answered nothing; the expected answer is {want!r}{verdict}")
+
+
 def refuse_every_proposal(candidate, reflective_dataset, components):
     """A proposer that never works, which a run must not report as "no improvement".
 
@@ -353,6 +395,15 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         ),
     )
     p.add_argument("--timeout", type=float, default=1800.0, help="seconds to wait for the run to settle")
+    p.add_argument(
+        "--judge",
+        choices=("chat", "system-one"),
+        default="chat",
+        help=(
+            "what the metric's judge binding is: a chat model, or a System One model it judges "
+            "through DSPy's System One client"
+        ),
+    )
     p.add_argument(
         "--metric-names-an-ungranted-binding",
         action="store_true",
@@ -378,6 +429,8 @@ def main(argv: list[str] | None = None) -> int:
     program = build_program()
     started_at = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
     metric = ungranted_binding_metric if args.metric_names_an_ungranted_binding else feedback_metric
+    if args.judge == "system-one":
+        metric = system_one_metric
 
     print(f"deploying to {endpoint}", flush=True)
     deployed = cmpnd.deploy(
@@ -394,6 +447,10 @@ def main(argv: list[str] | None = None) -> int:
 
     examples = [dspy.Example(**row).with_inputs("question") for row in EXAMPLES]
     proposer, lms = declared_proposer(args.proposer)
+    if args.judge == "system-one":
+        # The same model the chat judge names, declared as System One: the run's sealed
+        # credential serves both protocols, and the dialect picks the endpoint.
+        lms = {**lms, JUDGE_BINDING: cmpnd.SystemOne(JUDGE_MODEL)}
     print(
         f"optimizing with a budget of {args.metric_calls} metric calls, "
         f"proposer={args.proposer}, bindings={sorted(lms)}, "
@@ -404,6 +461,7 @@ def main(argv: list[str] | None = None) -> int:
         "started_at": started_at,
         "parent_deployment_id": str(deployed),
         "proposer": args.proposer,
+        "judge": args.judge,
     }
 
     def optimize() -> Any:

cmpnd-0.45.0/tests/test_decision_client_spans.py

@@ -0,0 +1,144 @@
+"""A DSPy ``TypeSafe`` decision call is an LM call.
+
+``dspy.clients.typesafe.TypeSafe`` asks a System One model questions about a state. It
+spends tokens and records an LM-shaped history entry, but it is not a ``dspy.BaseLM``, so
+DSPy's ``with_callbacks`` hands its calls to ``on_module_start``. The callback recognizes
+the client and records an LM span with a usage observation, as it does for a chat call.
+
+Each case runs DSPy's own ``TypeSafe.__call__`` under DSPy's own callback dispatch. Only
+the network step is a stand-in: a ``typesafe_sdk`` module whose client answers from a
+fixture.
+"""
+
+from __future__ import annotations
+
+import sys
+from types import ModuleType, SimpleNamespace
+from typing import Any
+from unittest import mock
+
+import pytest
+
+from cmpnd import models
+from cmpnd.configuration import configure
+from cmpnd.context import clear_context
+
+dspy = pytest.importorskip("dspy")
+typesafe = pytest.importorskip("dspy.clients.typesafe", reason="this DSPy has no TypeSafe decision client")
+
+
+class _RecordingExporter:
+    def __init__(self) -> None:
+        self.spans: list[Any] = []
+
+    def export_span(self, span: Any) -> None:
+        self.spans.append(span)
+
+
+class _Client:
+    """`typesafe_sdk.TypeSafeClient`, answering every turn with one decision.
+
+    The test environment does not install `typesafe-sdk`, so this copies the
+    signatures of 0.7.5's constructor and `system_one` by hand. Neither takes
+    `**kwargs`, so a call the real client would reject raises here too.
+    """
+
+    constructed: list[dict[str, Any]] = []
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        model: str | None = None,
+        retry: Any = None,
+        timeout: Any = None,
+        headers: Any = None,
+        transport: Any = None,
+        http_client: Any = None,
+        base_url: str | None = None,
+        compression: Any = None,
+    ) -> None:
+        _Client.constructed.append({"api_key": api_key, "model": model, "timeout": timeout, "base_url": base_url})
+
+    def __enter__(self) -> _Client:
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        return None
+
+    def system_one(
+        self,
+        state: Any,
+        questions: Any,
+        *,
+        model: str | None = None,
+        assets: Any = None,
+        retry: Any = None,
+        timeout: Any = None,
+        extra_headers: Any = None,
+        extra_body: Any = None,
+        response_model: Any = None,
+    ) -> Any:
+        return SimpleNamespace(
+            model="jev-1.14.0",
+            usage=SimpleNamespace(input_tokens=31, output_tokens=2),
+            answers={"grounded": SimpleNamespace(noul="yes", confidence=0.9)},
+        )
+
+
+@pytest.fixture(autouse=True)
+def _sdk_configured():
+    configure(api_key="test_key", endpoint="http://localhost:8000")
+    _Client.constructed.clear()
+    stand_in = ModuleType("typesafe_sdk")
+    stand_in.TypeSafeClient = _Client  # pyright: ignore[reportAttributeAccessIssue]
+    with mock.patch.dict(sys.modules, {"typesafe_sdk": stand_in}):
+        yield
+    clear_context()
+
+
+def _spans_of(client: Any) -> list[Any]:
+    from cmpnd.callback import CmpndCallback
+
+    with mock.patch("cmpnd.exporter.ensure_exporter_started", autospec=True):
+        callback = CmpndCallback()
+    recorder = _RecordingExporter()
+    with (
+        mock.patch("cmpnd.exporter.get_exporter", autospec=True, return_value=recorder),
+        dspy.context(callbacks=[callback]),
+    ):
+        answers = client(state="the reply cites its source", questions={"grounded": "Is it grounded?"})
+    assert answers == {"grounded": {"noul": "yes", "confidence": 0.9}}
+    return recorder.spans
+
+
+def test_a_decision_call_records_an_lm_span_with_its_usage():
+    spans = _spans_of(typesafe.TypeSafe("jev-latest", cache=False))
+
+    assert [span.span_type for span in spans] == [models.SpanType.LM_CALL]
+    assert [kwargs["model"] for kwargs in _Client.constructed] == ["jev-latest"]
+    observation = spans[0].to_api_dict()["lm_usage"]
+    assert observation["usage_reported"] is True
+    assert observation["prompt_tokens"] == 31
+    assert observation["completion_tokens"] == 2
+    assert observation["model_reported"] == "jev-1.14.0"
+    # The protocol it spoke, which the token field names alone would call chat.
+    assert observation["usage_dialect"] == "system_one"
+    # System One serves nothing from a cache, so the whole prompt is fresh input, as
+    # credentialed egress records the same call.
+    assert observation["prompt_inclusion"] == "excludes_cache_reads"
+    assert observation["fresh_input_tokens"] == 31
+
+
+def test_a_decision_call_keeps_the_brokers_join_key():
+    """A brokered client puts the broker's `egress_call_id` on its response, and the
+    observation carries it, so serve joins the span to egress's record of the call."""
+
+    class Brokered(typesafe.TypeSafe):
+        @staticmethod
+        def _response(response: Any) -> dict[str, Any]:
+            return {**typesafe.TypeSafe._response(response), "egress_call_id": "egc_judge"}
+
+    spans = _spans_of(Brokered("jev-latest", cache=False))
+
+    assert spans[0].to_api_dict()["lm_usage"]["egress_call_id"] == "egc_judge"

cmpnd-0.45.0/tests/test_system_one.py

@@ -0,0 +1,106 @@
+"""``cmpnd.SystemOne`` — a run's binding for a System One decision model.
+
+A System One model (TypeSafe's Jev, or the same schema served by another gateway) is
+not a chat model: a hosted judge built on ``dspy.experimental.TypeSafe`` asks it a set of
+questions about a state. ``cmpnd.SystemOne(model)`` in ``lms`` is the one way a run says
+a binding is one, and these tests hold the two things it writes: the binding the
+dispatch resolves a credential from, and the declaration the kernel builds its client
+from.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+import cmpnd
+from cmpnd import lm_configuration as lc
+from cmpnd import optimization
+
+
+@pytest.fixture(autouse=True)
+def reset():
+    lc.reset()
+    yield
+    lc.reset()
+
+
+def _config(lms):
+    config: dict = {}
+    optimization._lms_config(config, lms)
+    return config
+
+
+def test_a_system_one_binding_travels_as_its_model_alone():
+    """The dispatch resolves the credential from the model and nothing else, so the wire
+    entry is a plain binding: no sampling, because System One takes none."""
+    assert _config({"judge": cmpnd.SystemOne("lunaroute/djev")}) == {"lms": {"judge": {"model": "lunaroute/djev"}}}
+
+
+def test_its_declaration_says_system_one():
+    judge = cmpnd.SystemOne("typesafe/jev-latest")
+    assert lc.resolve({"judge": judge}) == {
+        "judge": {
+            "model": "typesafe/jev-latest",
+            "supported_params": [],
+            "supports_response_schema": False,
+            "dialect": "system_one",
+        }
+    }
+
+
+def test_a_chat_declaration_carries_no_dialect():
+    """Chat is what a declaration without the key already means, so a chat binding's
+    declaration is byte-for-byte what it was before System One existed."""
+    lm = type("LM", (), {"model": "openai/gpt-4o"})()
+    lc.configure_lm(lm, supported_params=["response_format"])
+    assert "dialect" not in lc.resolve({"critic": lm})["critic"]
+
+
+def test_a_restored_system_one_declaration_round_trips():
+    declaration = {
+        "model": "lunaroute/clef-flash",
+        "supported_params": [],
+        "supports_response_schema": False,
+        "dialect": "system_one",
+    }
+    lc.restore({"judge": declaration})
+    assert lc.resolve({"judge": "lunaroute/clef-flash"}) == {"judge": declaration}
+
+
+@pytest.mark.parametrize(
+    "declaration, match",
+    [
+        ({"dialect": "embedding"}, "dialect"),
+        ({"dialect": "typesafe"}, "dialect"),
+        ({"dialect": "system_one", "supported_params": ["temperature"]}, "takes no"),
+        ({"dialect": "system_one", "supports_response_schema": True}, "takes no"),
+    ],
+)
+def test_an_unusable_dialect_declaration_is_refused(declaration, match):
+    with pytest.raises(lc.LMConfigurationError, match=match):
+        lc.restore({"judge": {"model": "typesafe/jev-latest", **declaration}})
+
+
+@pytest.mark.parametrize("model", ["jev-latest", "", "  ", "typesafe/", 42])
+def test_a_system_one_model_must_name_its_credential(model):
+    """The prefix names the credential the platform spends, so a bare model name has no
+    credential to resolve and is refused where it is written."""
+    with pytest.raises(ValueError, match="SystemOne"):
+        cmpnd.SystemOne(model)
+
+
+class TypeSafe:
+    """Stands in for ``dspy.experimental.TypeSafe``, which DSPy releases before 3.4 lack.
+    The refusal reads the decision-client flag, as DSPy's own ``Predict`` does."""
+
+    supports_decision_requests = True
+
+    def __init__(self, model):
+        self.model = model
+
+
+def test_a_decision_client_in_lms_points_at_system_one():
+    """A ``TypeSafe`` carries a key and a URL, not a credential name, so it cannot be a
+    hosted binding. The refusal says what to write instead."""
+    with pytest.raises(ValueError, match=r"cmpnd\.SystemOne"):
+        _config({"judge": TypeSafe("jev-latest")})

{cmpnd-0.44.0 → cmpnd-0.45.0}/uv.lock

@@ -496,7 +496,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.44.0"
+version = "0.45.0"
 source = { editable = "." }
 dependencies = [
     { name = "dspy" },