cmpnd 0.57.0__tar.gz → 0.58.0__tar.gz

{cmpnd-0.57.0 → cmpnd-0.58.0}/AGENTS.md

@@ -123,6 +123,40 @@ parameter, and a spec-less mock accepts one anyway.
 with real LLMs (`CMPND_E2E_*` keys). It never uses a mock or an in-process
 fake, and it runs only locally.
 
+## DSPy versions under test
+
+The SDK supports DSPy 3.3.x and 3.4.x, and `dependencies` floors DSPy at
+3.3.0. `pyproject.toml` declares one dependency group per DSPy version the
+`sdk-test` matrix tests, such as `dspy-3-4-1 = ["dspy==3.4.1"]`.
+`[tool.uv] conflicts` makes the groups mutually exclusive, so `uv.lock` holds a
+whole tree for each DSPy. Dependency groups never reach the wheel, so users
+still install against the `dspy>=…` floor in `dependencies`.
+
+- A plain `uv sync` or `uv run` installs the default group, the newest tested
+  DSPy.
+- `scripts/install-test-env.sh <python> <dspy>` builds `.venv` from one group's
+  locked tree, as each `sdk-test` leg in `ci-sdk.yml` does. From the repo root,
+  run `just sdk-test-env 3.13 3.3.0`, then, from `python-sdk/`,
+  `.venv/bin/python -m pytest tests/ -k "not e2e"`. `uv sync --extra dev` in
+  `python-sdk/` returns to the default group.
+- `--latest` resolves every package fresh, as a user's install today would.
+  With the DSPy version `newest` it pins no DSPy either. The daily
+  `sdk-latest-dependencies.yml` run uses both: every sdk-test leg, plus one
+  leg on the newest DSPy, which is the first to see a DSPy release no group
+  tests yet. A failure there alerts Slack.
+- A DSPy release can pin some packages exactly, such as gepa (`dspy==3.3.0`
+  pins gepa 0.1.1). Its group locks those packages at the pinned versions. The
+  `mcp` extra floors DSPy at 3.3.1, so it conflicts with the `dspy-3-3-0`
+  group.
+
+To test another DSPy version, add its group to `[dependency-groups]` and to
+the first `conflicts` list, add a conflict with the `mcp` extra if it is below
+3.3.1, add the leg to `sdk-test`'s matrix and to
+`sdk-latest-dependencies.yml`, and run `uv lock`.
+`.github/scripts/test_workflows.py` fails while the groups and the matrix
+disagree. To move the default, change `default-groups` and refresh the span
+reference fixture with `uv run python -m tests.span_reference_fixture`.
+
 ## Two packages, one published distribution
 
 `cmpnd` (`cmpnd/`) is the SDK. `cmpnd_ingest` (`ingest/cmpnd_ingest/`) is the

{cmpnd-0.57.0 → cmpnd-0.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.57.0
+Version: 0.58.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
-Requires-Dist: dspy>=3.1.3
+Requires-Dist: dspy>=3.3.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: ipython>=8.20
 Requires-Dist: pydantic>=2.0

{cmpnd-0.57.0 → cmpnd-0.58.0}/cmpnd/_authored_import.py

@@ -25,7 +25,7 @@ def _built_lms(root: Path):
 
     The check reads objects the import built and parses no source. It wraps the
     ``__init__`` of ``dspy.BaseLM`` and of every LM class that defines its own, because
-    ``dspy.LM`` before dspy 3.3 never calls ``BaseLM.__init__``. It names the innermost
+    an LM subclass need not call ``BaseLM.__init__``. It names the innermost
     module of the bundle on the stack, so an LM a helper module builds is named by that
     module, and records each LM once, however many of the wrapped constructors it runs.
     """

{cmpnd-0.57.0 → cmpnd-0.58.0}/cmpnd/_gepa_patch.py

@@ -172,9 +172,6 @@ def patch_gepa() -> None:
 
     import dspy
 
-    if not hasattr(dspy, "GEPA"):
-        return
-
     # Resolve callback support once, at patch time — not per compile — so the
     # answer matches the installed gepa the patch bound to.
     has_callbacks = _gepa_supports_callbacks()
@@ -223,10 +220,10 @@ def unpatch_gepa() -> None:
         _gepa_patched = False
         return
 
-    GEPA = getattr(dspy, "GEPA", None)
-    if GEPA is not None and hasattr(GEPA, "_cmpnd_original_init"):
-        GEPA.__init__ = GEPA._cmpnd_original_init
-        GEPA.compile = GEPA._cmpnd_original_compile
-        del GEPA._cmpnd_original_init
-        del GEPA._cmpnd_original_compile
+    GEPA = dspy.GEPA
+    if hasattr(GEPA, "_cmpnd_original_init"):
+        GEPA.__init__ = GEPA._cmpnd_original_init  # pyright: ignore[reportAttributeAccessIssue]
+        GEPA.compile = GEPA._cmpnd_original_compile  # pyright: ignore[reportAttributeAccessIssue]
+        del GEPA._cmpnd_original_init  # pyright: ignore[reportAttributeAccessIssue]
+        del GEPA._cmpnd_original_compile  # pyright: ignore[reportAttributeAccessIssue]
     _gepa_patched = False

{cmpnd-0.57.0 → cmpnd-0.58.0}/cmpnd/callback.py

@@ -1101,7 +1101,7 @@ class _ModuleMixin(_CallbackBase):
         """Map DSPy module instance to span type."""
         if isinstance(instance, dspy.Retrieve):
             return models.SpanType.RETRIEVE
-        elif isinstance(instance, getattr(dspy, "RLM", type(None))):
+        elif isinstance(instance, dspy.RLM):
             return models.SpanType.RLM
         elif isinstance(instance, dspy.ReAct):
             return models.SpanType.REACT

{cmpnd-0.57.0 → cmpnd-0.58.0}/cmpnd/optimizers/tracker.py

@@ -1332,15 +1332,13 @@ def code_component_types(student: Any) -> dict[str, str]:
     serve cannot tell source from prose on its own, and without this a Flex's module
     source renders as a word-diffed paragraph.
 
-    Empty for a program with no Flex, for a dspy without `Flex`, and for anything that is
-    not a dspy module.
+    Empty for a program with no Flex, and for anything that is not a dspy module.
     """
     import dspy
 
-    flex_cls = getattr(dspy, "Flex", None)
-    if flex_cls is None or not isinstance(student, dspy.Module):
+    if not isinstance(student, dspy.Module):
         return {}
-    return {name: COMPONENT_KIND_CODE for name, sub in student.named_parameters() if isinstance(sub, flex_cls)}
+    return {name: COMPONENT_KIND_CODE for name, sub in student.named_parameters() if isinstance(sub, dspy.Flex)}
 
 
 def enrich_from_program(

{cmpnd-0.57.0 → cmpnd-0.58.0}/docs/cli.md

@@ -59,9 +59,6 @@ and sends the id.
   `cmpnd programs purge --all` empties the Trash. Nothing restores a purged
   program. Both ask for confirmation at a terminal and need `--force` anywhere
   else. A live program is never purged.
-  A program created by name cannot be purged yet. It stays in the Trash, where
-  it no longer counts toward a plan's program cap, and `purge --all` answers
-  how many such programs it kept.
 
 A program in the Trash or purged gives up its name. The next
 `cmpnd programs create`, `cmpnd deploy` or SDK run under that name gets a new

{cmpnd-0.57.0 → cmpnd-0.58.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.57.0"
+version = "0.58.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -28,7 +28,7 @@ classifiers = [
 ]
 
 dependencies = [
-    "dspy>=3.1.3",
+    "dspy>=3.3.0",
     # Reached directly by the SDK (cmpnd/optimization.py's poll, cmpnd/datasets.py)
     # and by the ingest transport this wheel bundles (ingest/cmpnd_ingest), whose
     # only non-stdlib import it is.
@@ -129,6 +129,33 @@ fake-provider = [
 [tool.uv.sources]
 cmpnd-fake-provider = { path = "../fake-provider", editable = true }
 
+# One group per DSPy version the test matrix runs, so uv.lock locks a whole tree for
+# each and a test leg installs from the lock with only DSPy varying
+# (`scripts/install-test-env.sh`; AGENTS.md, "DSPy versions under test"). Dependency
+# groups never reach the wheel's metadata, so a user's install still takes
+# `dspy>=3.3.0` above. Each group name is `dspy-` and the version with dots turned to
+# dashes.
+[dependency-groups]
+dspy-3-4-1 = ["dspy==3.4.1"]
+dspy-3-4-0 = ["dspy==3.4.0"]
+dspy-3-3-1 = ["dspy==3.3.1"]
+dspy-3-3-0 = ["dspy==3.3.0"]
+
+[tool.uv]
+# A plain `uv sync` or `uv run` installs the newest tested DSPy.
+default-groups = ["dspy-3-4-1"]
+# The groups pin different DSPy versions, so uv resolves a separate fork for each.
+# The mcp extra floors dspy at 3.3.1, so it conflicts with the dspy-3-3-0 group.
+conflicts = [
+    [
+        { group = "dspy-3-4-1" },
+        { group = "dspy-3-4-0" },
+        { group = "dspy-3-3-1" },
+        { group = "dspy-3-3-0" },
+    ],
+    [{ extra = "mcp" }, { group = "dspy-3-3-0" }],
+]
+
 [project.scripts]
 cmpnd = "cmpnd.cli:main"
 
@@ -141,8 +168,8 @@ Homepage = "https://cmpnd.ai"
 # the two move together or a release fails at upload. hatchling 1.32.0 stamps
 # 2.5, and the twine inside the pinned pypa/gh-action-pypi-publish accepts it;
 # that pairing is what `twine check --strict` in sdk-lint proves on every PR.
-# `==` so a backend bump arrives as a Renovate PR that runs that check, rather
-# than as a silent resolution on release day.
+# `==` so a backend bump is a reviewed edit here that runs that check, rather
+# than a silent resolution on release day.
 requires = ["hatchling==1.32.0"]
 build-backend = "hatchling.build"
 

{cmpnd-0.57.0 → cmpnd-0.58.0}/scripts/check-pip-install.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # Install cmpnd with pip's own resolver and check that the installed package
 # imports and instruments DSPy. Called by .github/workflows/ci-sdk.yml (the
-# sdk-test leg for Python 3.15).
+# sdk-test-py315 job, the sdk-test leg for Python 3.15).
 #
 # `pip install cmpnd` is the install PyPI advertises. pip honours the
 # requires-python upper bounds that uv ignores, so this check fails when no

cmpnd-0.58.0/scripts/install-test-env.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# Build python-sdk/.venv for one sdk-test leg: the SDK and its dev extra, on one
+# Python, at one DSPy version.
+#
+# CALLED BY: .github/workflows/ci-sdk.yml (sdk-test and sdk-test-py315),
+# .github/workflows/sdk-latest-dependencies.yml (with --latest), `just
+# sdk-test-env` at the repo root, and scripts/test-in-linux.sh.
+#
+# The install reads uv.lock. pyproject.toml declares one dependency group per
+# tested DSPy, named `dspy-` and the version with dots turned to dashes, and the lock
+# holds a whole tree for each. A leg syncs its group's tree exactly, so only DSPy,
+# and whatever that DSPy itself pins, differs between legs. A red leg means the
+# change broke something rather than that an upstream release did. The lock moves only
+# by a reviewed commit: a security upgrade when bin/vulncheck fails on an advisory a
+# bump would fix, and any other upgrade as a deliberate lock bump.
+#
+# --latest resolves every package fresh, with only the Python and DSPy versions
+# pinned, as a user's install today would. With the DSPy version `newest`, it pins no
+# DSPy either, so the install takes the newest release `dspy>=…` admits, as `pip
+# install cmpnd` does. It prints the DSPy it installed. The daily run in
+# sdk-latest-dependencies.yml uses it.
+#
+# Usage: scripts/install-test-env.sh [--latest] <python-version> <dspy-version>
+#   e.g. scripts/install-test-env.sh 3.13 3.3.0
+#        scripts/install-test-env.sh --latest 3.13 3.4.1
+#        scripts/install-test-env.sh --latest 3.14 newest
+set -euo pipefail
+
+usage() {
+    echo "usage: $0 [--latest] <python-version> <dspy-version>" >&2
+    exit 2
+}
+
+latest=false
+if [ "${1:-}" = "--latest" ]; then
+    latest=true
+    shift
+fi
+[ "$#" -eq 2 ] || usage
+python_version=$1
+dspy_version=$2
+
+cd "$(dirname "${BASH_SOURCE[0]}")/.."
+
+if [ "$latest" = true ]; then
+    uv venv --clear --python "$python_version" .venv
+    if [ "$dspy_version" = newest ]; then
+        uv pip install --python .venv/bin/python -e ".[dev]"
+    else
+        uv pip install --python .venv/bin/python -e ".[dev]" "dspy==$dspy_version"
+    fi
+    echo "install-test-env: installed $(uv pip freeze --python .venv/bin/python | grep -i '^dspy==')"
+    exit 0
+fi
+if [ "$dspy_version" = newest ]; then
+    echo "install-test-env: the DSPy version newest needs --latest. uv.lock locks one tree per tested DSPy, and a locked install names one." >&2
+    exit 2
+fi
+
+group="dspy-${dspy_version//./-}"
+if ! grep -qE "^$group = " pyproject.toml; then
+    echo "install-test-env: pyproject.toml declares no dependency group $group. To test dspy $dspy_version, add $group = [\"dspy==$dspy_version\"] to [dependency-groups] and to the conflicts list in [tool.uv], then run uv lock." >&2
+    exit 2
+fi
+# --frozen installs exactly what uv.lock holds and never re-locks. sdk-lint's
+# `uv lock --check` fails when the lock is stale against pyproject.toml.
+uv sync --frozen --extra dev --no-default-groups --group "$group" --python "$python_version"

{cmpnd-0.57.0 → cmpnd-0.58.0}/scripts/test-in-linux.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Run the SDK suite (or a subset) on Linux, in a container that resolves its own
+# Run the SDK suite (or a subset) on Linux, in a container that installs its own
 # dependencies.
 #
 # The lane exists because some of what this SDK has to get right is only
@@ -16,14 +16,16 @@
 #
 # It deliberately does NOT mount the host `.venv`: those wheels are macOS
 # wheels, and a container reusing them fails in ways that teach you nothing about
-# the code. uv resolves fresh inside, which is also what makes this a real answer
-# to "would CI see this too". The copy also drops `.pyc` files because their
-# embedded source paths may name a worktree that moved or no longer exists.
+# the code. uv installs from uv.lock inside, which is also what makes this a real
+# answer to "would CI see this too". SDK_TEST_DSPY_VERSION picks a DSPy group the
+# way an sdk-test leg does (scripts/install-test-env.sh). The copy also drops
+# `.pyc` files because their embedded source paths may name a worktree that moved
+# or no longer exists.
 #
 # Usage — everything, or a pytest selector:
 #   python-sdk/scripts/test-in-linux.sh
 #   python-sdk/scripts/test-in-linux.sh tests/test_exporter_queue.py -v
-#   SDK_TEST_DSPY_VERSION=3.1.3 python-sdk/scripts/test-in-linux.sh tests/test_run_attribution_paths.py -v
+#   SDK_TEST_DSPY_VERSION=3.3.0 python-sdk/scripts/test-in-linux.sh tests/test_run_attribution_paths.py -v
 #
 # Called by: `just sdk-test-linux` (repo root). No CI workflow — CI already runs
 # on Linux; this is the local mirror of what it does.
@@ -53,8 +55,7 @@ cp -r /repo/python-sdk /repo/fake-provider /repo/docs /work/
 rm -rf /work/python-sdk/.venv
 find /work/python-sdk -name "*.pyc" -delete
 if [ -n "$SDK_TEST_DSPY_VERSION" ]; then
-    uv venv --python 3.12 --quiet
-    uv pip install --quiet -e ".[dev]" "dspy==$SDK_TEST_DSPY_VERSION"
+    scripts/install-test-env.sh 3.12 "$SDK_TEST_DSPY_VERSION"
 else
     uv sync --extra dev --quiet
 fi

{cmpnd-0.57.0 → cmpnd-0.58.0}/tests/span_reference_fixture.py

@@ -19,6 +19,7 @@ import gzip
 import hashlib
 import json
 import re
+import tomllib
 import uuid
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -109,13 +110,18 @@ def render(doc: dict[str, Any]) -> str:
     return json.dumps(doc, sort_keys=True, ensure_ascii=False, separators=(",", ":")) + "\n"
 
 
-def locked_dspy_version() -> str:
-    """The DSPy version ``python-sdk/uv.lock`` pins, which rendered the fixture's prompts."""
-    lock = (Path(__file__).resolve().parents[1] / "uv.lock").read_text()
-    match = re.search(r'\[\[package\]\]\nname = "dspy"\nversion = "([^"]+)"', lock)
-    if match is None:
-        raise RuntimeError("uv.lock pins no dspy version")
-    return match.group(1)
+def default_dspy_version() -> str:
+    """The DSPy version a plain ``uv sync`` installs, which rendered the fixture's prompts.
+
+    That is the version pyproject.toml's default dependency group pins.
+    """
+    pyproject = tomllib.loads((Path(__file__).resolve().parents[1] / "pyproject.toml").read_text())
+    (group,) = pyproject["tool"]["uv"]["default-groups"]
+    (requirement,) = pyproject["dependency-groups"][group]
+    name, _, version = requirement.partition("==")
+    if name != "dspy" or not version:
+        raise RuntimeError(f"default group {group} pins no dspy version: {requirement!r}")
+    return version
 
 
 def read_committed() -> str:

{cmpnd-0.57.0 → cmpnd-0.58.0}/tests/test_adapter_reentrancy.py

@@ -14,20 +14,14 @@ import pytest
 pytest.importorskip("dspy")
 
 import dspy
+from dspy.adapters.baml_adapter import BAMLAdapter
 from dspy.utils.dummies import DummyLM
 
 from cmpnd.configuration import configure
 from cmpnd.context import clear_context, get_current_span
 from tests import _traced_run
 
-try:
-    from dspy.adapters.baml_adapter import BAMLAdapter
-except ImportError:  # pragma: no cover - older DSPy without BAML
-    BAMLAdapter = None
-
-ADAPTERS = [dspy.ChatAdapter, dspy.JSONAdapter, dspy.XMLAdapter]
-if BAMLAdapter is not None:
-    ADAPTERS.append(BAMLAdapter)
+ADAPTERS = [dspy.ChatAdapter, dspy.JSONAdapter, dspy.XMLAdapter, BAMLAdapter]
 
 
 @pytest.fixture(autouse=True)

{cmpnd-0.57.0 → cmpnd-0.58.0}/tests/test_lm_usage_shapes.py

@@ -37,10 +37,8 @@ pytest.importorskip("dspy")
 def _typed_lm_types_available() -> bool:
     """Report whether the installed DSPy ships the typed LM contract.
 
-    ``dspy.core.types`` (``LMUsage``, ``LMResponse``) arrived in DSPy 3.3.0.
-    Measured across the versions ``.github/workflows/ci-sdk.yml`` pins: absent on
-    3.1.3, 3.2.0 and 3.2.1, present on 3.3.0 and 3.3.1, and removed in 3.4.0b1,
-    whose ``dspy.core.types`` raises ``ImportError``. Probed by import rather
+    ``dspy.core.types`` (``LMUsage``, ``LMResponse``) is present on DSPy 3.3.0 and
+    3.3.1 and removed in 3.4.0b1, whose ``dspy.core.types`` raises ``ImportError``. Probed by import rather
     than by version number, so the answer stays right whatever the matrix pins
     next.
 

{cmpnd-0.57.0 → cmpnd-0.58.0}/tests/test_program_lineage_persist.py

@@ -105,11 +105,10 @@ def test_loaded_tag_feeds_compiled_from(tmp_path):
 
 
 def test_wrappers_forward_only_callers_args():
-    # The patch is installed process-wide, and dump_state/load_state signatures
-    # differ across DSPy versions (allow_unsafe_lm_state postdates 3.1.x). The
-    # wrappers must forward only what the caller passed — a bare positional
-    # round-trip must not raise from an injected keyword. Guards the 3.1.3 CI
-    # break where the wrapper forced allow_unsafe_lm_state.
+    # The patch is installed process-wide, so the wrappers must forward only what
+    # the caller passed, whatever dump_state/load_state signature the installed
+    # DSPy has: a bare positional round-trip must not raise from an injected
+    # keyword such as allow_unsafe_lm_state.
     prog = _Tiny()
     state = prog.dump_state()  # no json_mode kwarg
     _Tiny().load_state(state)  # no allow_unsafe_lm_state kwarg

{cmpnd-0.57.0 → cmpnd-0.58.0}/tests/test_rlm_patch.py

@@ -7,6 +7,7 @@ active cmpnd callback while preserving the func's signature (the interpreter
 builds its sandbox stub from inspect.signature).
 """
 
+import contextlib
 import inspect
 import uuid
 
@@ -23,6 +24,18 @@ def _configured():
     yield
 
 
+@pytest.fixture
+def use_callbacks():
+    """Installs DSPy callbacks for the rest of one test through dspy.context.
+
+    monkeypatch cannot set them: dspy.settings serves callbacks from its config
+    through __getattr__, so pytest 9.2's monkeypatch records the attribute as
+    unset and its teardown delattr fails.
+    """
+    with contextlib.ExitStack() as stack:
+        yield lambda *cbs: stack.enter_context(dspy.context(callbacks=list(cbs)))
+
+
 def _make_rlm():
     def add_pages(first: int, last: int) -> int:
         """Sum a page range."""
@@ -52,7 +65,7 @@ def test_wrapped_tool_preserves_signature():
     assert inspect.signature(shim) == inspect.signature(add_pages)
 
 
-def test_tool_span_created_and_nested_under_rlm(monkeypatch):
+def test_tool_span_created_and_nested_under_rlm(monkeypatch, use_callbacks):
     """With a callback and an RLM.forward span on the stack, invoking a wrapped
     tool creates a TOOL span parented to the RLM span."""
     _rlm_patch._patched = False
@@ -61,7 +74,7 @@ def test_tool_span_created_and_nested_under_rlm(monkeypatch):
     tracked = []
     cb = callback.CmpndCallback()
     monkeypatch.setattr(cb, "_track_span", lambda span: tracked.append(span))
-    monkeypatch.setattr(dspy.settings, "callbacks", [cb], raising=False)
+    use_callbacks(cb)
 
     context.clear_context()
     context.set_current_trace(models.TraceBuilder(trace_id=uuid.uuid4()))
@@ -86,7 +99,7 @@ def test_tool_span_created_and_nested_under_rlm(monkeypatch):
     assert span.trace_id == rlm_span.trace_id
 
 
-def test_multiple_callbacks_emit_one_tool_span(monkeypatch):
+def test_multiple_callbacks_emit_one_tool_span(monkeypatch, use_callbacks):
     """Two registered CmpndCallbacks share one span-stack contextvar, so the
     shim dispatches to only the first — one tool span, stack balanced, no
     tool-span-nested-under-tool-span corruption."""
@@ -98,7 +111,7 @@ def test_multiple_callbacks_emit_one_tool_span(monkeypatch):
     cb_b = callback.CmpndCallback()
     monkeypatch.setattr(cb_a, "_track_span", lambda span: tracked_a.append(span))
     monkeypatch.setattr(cb_b, "_track_span", lambda span: tracked_b.append(span))
-    monkeypatch.setattr(dspy.settings, "callbacks", [cb_a, cb_b], raising=False)
+    use_callbacks(cb_a, cb_b)
 
     context.clear_context()
     context.set_current_trace(models.TraceBuilder(trace_id=uuid.uuid4()))
@@ -136,14 +149,14 @@ def test_tracing_off_calls_func_without_span():
         dspy.settings.callbacks = original
 
 
-def test_raising_tool_closes_span_and_reraises(monkeypatch):
+def test_raising_tool_closes_span_and_reraises(monkeypatch, use_callbacks):
     _rlm_patch._patched = False
     _rlm_patch.patch_rlm_tools()
 
     tracked = []
     cb = callback.CmpndCallback()
     monkeypatch.setattr(cb, "_track_span", lambda span: tracked.append(span))
-    monkeypatch.setattr(dspy.settings, "callbacks", [cb], raising=False)
+    use_callbacks(cb)
 
     def boom(x: int) -> int:
         raise ValueError("nope")

{cmpnd-0.57.0 → cmpnd-0.58.0}/tests/test_span_references.py

@@ -350,12 +350,12 @@ def test_the_committed_thirty_turn_fixture_is_what_the_sdk_emits():
     """serve's Postgres test ingests this file, so it must be the SDK's current output.
 
     The rendered prompts are DSPy's text, so the comparison holds only on the
-    DSPy the lockfile pins; the CI matrix's other versions skip it.
+    DSPy the default dependency group pins; the CI matrix's other versions skip it.
     """
     from tests import span_reference_fixture
 
-    if dspy.__version__ != span_reference_fixture.locked_dspy_version():
-        pytest.skip(f"the fixture was rendered by the locked DSPy, not {dspy.__version__}")
+    if dspy.__version__ != span_reference_fixture.default_dspy_version():
+        pytest.skip(f"the fixture was rendered by the default group's DSPy, not {dspy.__version__}")
     fresh = span_reference_fixture.render(span_reference_fixture.build())
     assert span_reference_fixture.read_committed() == fresh, (
         "docs/schemas/span-references/rlm-30-turns.json.gz is stale; "