cmpnd 0.85.1__tar.gz → 0.86.0__tar.gz

{cmpnd-0.85.1 → cmpnd-0.86.0}/PKG-INFO

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

{cmpnd-0.85.1 → cmpnd-0.86.0}/cmpnd/_http.py

@@ -16,7 +16,7 @@ from typing import Any
 from urllib.parse import urlsplit
 
 import httpx
-from cmpnd_ingest import client_floor
+from cmpnd_ingest import client_floor, user_agent
 
 
 class ApiError(Exception):
@@ -79,16 +79,22 @@ def server_detail(response: httpx.Response) -> str:
 
 
 def new_client(**kwargs: Any) -> httpx.Client:
-    """An ``httpx.Client`` that warns when the server no longer supports this
-    release (:mod:`cmpnd_ingest.client_floor`).
+    """An ``httpx.Client`` that names this release to the server and warns when
+    the server no longer supports it (:mod:`cmpnd_ingest.client_floor`).
 
-    Every client the SDK builds comes from here, so every answer the platform
-    sends gets the check. A caller's own ``event_hooks`` run after it.
+    Every client the SDK builds comes from here, so every request carries the
+    release's ``User-Agent`` (:mod:`cmpnd_ingest.user_agent`) and every answer
+    the platform sends gets the check. A caller's own ``headers`` override the
+    ``User-Agent``, and its own ``event_hooks`` run after the check.
     """
     hooks = client_floor.event_hooks()
     for event, callers in (kwargs.pop("event_hooks", None) or {}).items():
         hooks.setdefault(event, []).extend(callers)
-    return httpx.Client(event_hooks=hooks, **kwargs)
+    # httpx.Headers matches names without regard to case, so a caller's `user-agent`
+    # replaces the default rather than travelling beside it.
+    headers = httpx.Headers(user_agent.headers())
+    headers.update(kwargs.pop("headers", None) or {})
+    return httpx.Client(event_hooks=hooks, headers=headers, **kwargs)
 
 
 _DEFAULT_PORTS = {"http": 80, "https": 443}

{cmpnd-0.85.1 → cmpnd-0.86.0}/cmpnd/cli/commands/admin.py

@@ -10,8 +10,8 @@ inspect, create, approve/reject the pending-signup queue, promote/demote admin,
 disable/enable, reset a password, and manage a user's API-key scopes). `cmpnd
 admin org plan …` and `cmpnd admin org overrides …` move an org between plans
 and override one of its limits, `cmpnd admin org flags …` pins a feature flag
-for one org, `cmpnd admin plans …` edits each plan's
-default limits and feature flags, and `cmpnd admin signup …` sets who may sign up
+for one org, `cmpnd admin plans …` edits a plan's draft, publishes it as a new
+version, moves orgs between versions and pins a plan's feature flags, and `cmpnd admin signup …` sets who may sign up
 and the plan a new account's org lands on. `cmpnd admin feature-flags …` reads and
 toggles the server's runtime flags. These hit
 /api/v1/admin/* and require an API key carrying the admin:* scopes — the server
@@ -259,24 +259,55 @@ def _register_user(sub: _SubParsersAction[ArgumentParser]) -> None:
     set_scopes.set_defaults(func=handle_user_set_scopes)
 
 
+def _positive_version(raw: str) -> int:
+    """A plan version is a whole number of 1 or more."""
+    try:
+        version = int(raw)
+    except ValueError:
+        version = 0
+    if version < 1:
+        raise ArgumentTypeError(f"{raw!r} is not a version: give a whole number of 1 or more")
+    return version
+
+
 def _register_plans(sub: _SubParsersAction[ArgumentParser]) -> None:
-    plans = sub.add_parser("plans", help="Each plan's default limits and feature flags")
+    plans = sub.add_parser("plans", help="Each plan's versions, draft and feature flags")
     psub = plans.add_subparsers(dest="plans_action")
 
-    ls = psub.add_parser("list", help="List every plan's limits and feature flags")
+    ls = psub.add_parser(
+        "list", help="List every plan's versions with their values and org counts, its draft and its feature flags"
+    )
     ls.set_defaults(func=handle_plans_list)
 
-    limits = psub.add_parser("limits", help="A plan's default limits")
-    lsub = limits.add_subparsers(dest="plans_limits_action")
-    limit_update = lsub.add_parser("update", help="Set a plan's default for a limit; 'none' means no limit")
-    limit_update.add_argument("plan", help=PLAN_HELP)
-    limit_update.add_argument("name", help="Limit name, such as optimizations.concurrent")
-    limit_update.add_argument("value", type=_limit_value, help="A whole number, or 'none' for no limit")
-    limit_update.set_defaults(func=handle_plans_limits_update)
-    limit_delete = lsub.add_parser("delete", help="Delete a plan's default for a limit")
-    limit_delete.add_argument("plan", help=PLAN_HELP)
-    limit_delete.add_argument("name", help="Limit name")
-    limit_delete.set_defaults(func=handle_plans_limits_delete)
+    # A published version never changes, so every value write goes to the plan's
+    # draft, which serve opens from the current version on the first write.
+    draft = psub.add_parser("draft", help="A plan's draft, the next version before it is published")
+    dsub = draft.add_subparsers(dest="plans_draft_action")
+    draft_update = dsub.add_parser(
+        "update", help="Set a value in the plan's draft, opening one if needed; 'none' means no limit"
+    )
+    draft_update.add_argument("plan", help=PLAN_HELP)
+    draft_update.add_argument("name", help="Limit name, such as optimizations.concurrent")
+    draft_update.add_argument("value", type=_limit_value, help="A whole number, or 'none' for no limit")
+    draft_update.set_defaults(func=handle_plans_draft_update)
+    draft_delete = dsub.add_parser("delete", help="Delete a value from the plan's draft, so it sets no limit")
+    draft_delete.add_argument("plan", help=PLAN_HELP)
+    draft_delete.add_argument("name", help="Limit name")
+    draft_delete.set_defaults(func=handle_plans_draft_delete)
+    draft_publish = dsub.add_parser("publish", help="Publish the plan's draft as its current version; it moves no org")
+    draft_publish.add_argument("plan", help=PLAN_HELP)
+    draft_publish.add_argument("--note", default="", help="Why this version exists")
+    draft_publish.set_defaults(func=handle_plans_draft_publish)
+
+    move = psub.add_parser("move", help="Move orgs to a published version of their plan; their overrides stay")
+    move.add_argument("plan", help=PLAN_HELP)
+    move.add_argument("version", type=_positive_version, help="The published version to move to")
+    who = move.add_mutually_exclusive_group(required=True)
+    who.add_argument(
+        "--from-version", dest="from_version", type=_positive_version, help="Move every org on this version"
+    )
+    who.add_argument("--org", dest="org_id", help="Move this one org")
+    move.set_defaults(func=handle_plans_move)
 
     flags = psub.add_parser("flags", help="A plan's feature flags")
     fsub = flags.add_subparsers(dest="plans_flags_action")
@@ -430,12 +461,21 @@ def handle_plans_list(client: api_client.ApiClient, _args: Any) -> Any:
     return client.get("/api/v1/admin/plans")
 
 
-def handle_plans_limits_update(client: api_client.ApiClient, args: Any) -> Any:
-    return client.put(f"/api/v1/admin/plans/{args.plan}/limits/{args.name}", json={"value": args.value})
+def handle_plans_draft_update(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(f"/api/v1/admin/plans/{args.plan}/draft/limits/{args.name}", json={"value": args.value})
+
+
+def handle_plans_draft_delete(client: api_client.ApiClient, args: Any) -> Any:
+    return client.delete(f"/api/v1/admin/plans/{args.plan}/draft/limits/{args.name}")
+
+
+def handle_plans_draft_publish(client: api_client.ApiClient, args: Any) -> Any:
+    return client.post(f"/api/v1/admin/plans/{args.plan}/draft/publish", json={"note": args.note})
 
 
-def handle_plans_limits_delete(client: api_client.ApiClient, args: Any) -> Any:
-    return client.delete(f"/api/v1/admin/plans/{args.plan}/limits/{args.name}")
+def handle_plans_move(client: api_client.ApiClient, args: Any) -> Any:
+    body: dict[str, Any] = {"org_id": args.org_id} if args.org_id is not None else {"from_version": args.from_version}
+    return client.post(f"/api/v1/admin/plans/{args.plan}/versions/{args.version}/move", json=body)
 
 
 def handle_plans_flags_update(client: api_client.ApiClient, args: Any) -> Any:

{cmpnd-0.85.1 → cmpnd-0.86.0}/cmpnd/cli/verbs.py

@@ -168,6 +168,8 @@ DOMAIN_VERBS: dict[str, str] = {
     "restore": "returns a program from the Trash with its history, which create would not",
     "purge": "deletes a program in the Trash for good, the irreversible step after trash",
     "rename": "gives a program a new current name and frees the old one for any program, which update would hide",
+    "publish": "freezes a plan's draft as its next version, which no write changes again and update would not say",
+    "move": "puts orgs on another version of their plan; the version and its values stay as they are",
 }
 
 #: Leaves naming a related collection or sub-record rather than an action.

{cmpnd-0.85.1 → cmpnd-0.86.0}/docs/cli.md

@@ -944,15 +944,17 @@ reject USER_ID --org-id ORG_ID` declines a pending membership.
 
 ### Plans, limits and signups
 
-Every org has a plan, `free`, `pro` or `enterprise`, and each plan sets
-default limits and feature flags. An org's own override beats its plan.
-`cmpnd admin org list` shows each org's plan, and `--plan free` keeps only the
-orgs on Free. `cmpnd admin org plan show ORG_ID` shows the org's plan and every
-limit, with the layer that set it. `cmpnd admin org plan update ORG_ID PLAN` moves the
-org. `cmpnd admin org overrides update ORG_ID NAME VALUE` overrides one limit,
-and a value of `none` lifts the plan's limit for that org.
-`cmpnd admin org overrides delete ORG_ID NAME` deletes the override, so the org
-follows its plan again.
+Every org has a plan, `free`, `pro` or `enterprise`, and follows one published
+version of it. A version sets the org's limits and never changes. An org's own
+override beats its version. `cmpnd admin org list` shows each org's plan, and
+`--plan free` keeps only the orgs on Free. `cmpnd admin org plan show ORG_ID`
+shows the org's plan, `plan_version`, the plan's `current_version` and every
+limit, with the layer that set it. `cmpnd admin org plan update ORG_ID PLAN`
+moves the org to that plan's current version, and leaves an org already on the
+plan where it is. `cmpnd admin org overrides update ORG_ID NAME VALUE`
+overrides one limit, and a value of `none` lifts the version's limit for that
+org. `cmpnd admin org overrides delete ORG_ID NAME` deletes the override, so
+the org follows its version again. Overrides stay through every move.
 
 `cmpnd admin org usage ORG_ID` shows what each limit bounds now, in `in_use`,
 and the org's activity in the last 24 hours, 7 days and 30 days, in `windows`.
@@ -971,11 +973,24 @@ their date survives only while a membership keeps it. `oldest_key_at` and
 the user still holds, because leaving an org deletes the user's keys there.
 Sign-ins are not recorded, and deployment keys do not count as the user's keys.
 
-`cmpnd admin plans list` shows every plan's limits and feature flags.
-`cmpnd admin plans limits update PLAN NAME VALUE` and `limits delete PLAN NAME`
-change a plan's default for every org on it. `cmpnd admin plans flags update
-PLAN NAME [--disabled]` pins a flag for the plan, and `flags delete` hands the
-plan back to the global default. A plan's flag must already exist, so create
+`cmpnd admin plans list` shows each plan's current version and its values,
+every published version with its values, publisher, note and org count, the
+draft, and the plan's feature flags. A change to a plan's limits takes three
+steps, and no org moves until the last:
+
+1. `cmpnd admin plans draft update PLAN NAME VALUE` sets a value in the plan's
+   draft, and `draft delete PLAN NAME` removes one, so the draft sets no limit
+   for it. The first edit opens the draft as a copy of the current version.
+2. `cmpnd admin plans draft publish PLAN --note TEXT` publishes the draft as the
+   plan's current version. New orgs land on it.
+3. `cmpnd admin plans move PLAN VERSION --from-version N` moves every org on
+   version N to VERSION, and `--org ORG_ID` moves one org. It answers `moved`,
+   the number of orgs it moved, and refuses a draft or a version the plan
+   lacks.
+
+`cmpnd admin plans flags update PLAN NAME [--disabled]` pins a flag for the
+plan, and `flags delete` hands the plan back to the global default. Flags have
+no versions. A plan's flag must already exist, so create
 it first with `cmpnd admin feature-flags set`.
 
 `cmpnd admin org flags list ORG_ID` shows every flag with the org's own row,

{cmpnd-0.85.1 → cmpnd-0.86.0}/docs/sdk-instrumentation.md

@@ -373,6 +373,8 @@ Two callers implement the waiting:
 
 Every API answer names the oldest cmpnd release the server supports, in the `X-Cmpnd-Minimum-Client-Version` header. `cmpnd_ingest/client_floor.py` reads it in an httpx response hook. When the installed `cmpnd` is older, it raises an `UpgradeRequiredWarning` once per process that names both versions and the command `pip install -U cmpnd`. The server refuses nothing for a client's version, so a call below the floor still goes through, and the warning appears beside whatever it does. Every client the SDK builds comes from `cmpnd._http.new_client`, which installs the hook, and the exporter installs it in `_client_kwargs`. `tests/test_client_floor.py` fails on an `httpx.Client` built any other way in `cmpnd/`. An install of `cmpnd_ingest` without `cmpnd` has no version to compare and says nothing. `CMPND_NO_UPGRADE_WARNING=1` silences the warning for a user who stays on an older release on purpose, and the warning names that switch. `cmpnd.UpgradeRequiredWarning` is public, so a `warnings` filter silences it in code.
 
+Every request names its release in the other direction, so the server can count which releases are in use. `cmpnd_ingest/user_agent.py` builds the `User-Agent` value, such as `cmpnd/0.85.2 python/3.12.13 httpx/0.28.1 dspy/3.4.1`. The first product is `cmpnd` for the SDK and `cmpnd-ingest` for a producer that installs only the transport, such as the optimizer's search process. A library that is not installed is left out. `cmpnd._http.new_client` and the exporter's `_client_kwargs` both send it. A caller that passes its own `User-Agent` to `new_client` keeps it. `tests/test_user_agent.py` checks the value that reaches the wire.
+
 ### The optimize loop and transient tolerance
 
 `optimization._poll_until_terminal` is what a caller blocks on for the length of a run, so one transient answer or one reset connection must not destroy a healthy run. It rides through transient answers on the shared budget, resetting after each successful poll, and never extends past the caller's `timeout` (default 600s per step) — a backoff wait is clipped by the deadline rather than overshooting it.

{cmpnd-0.85.1 → cmpnd-0.86.0}/ingest/cmpnd_ingest/exporter_http.py

@@ -34,7 +34,7 @@ from typing import Any, cast
 
 import httpx
 
-from . import client_floor, program_names, request_log, retry
+from . import client_floor, program_names, request_log, retry, user_agent
 from .bodies import EncodedTraceBody, SpanBody, TraceBody
 from .protocols import (
     EvalRunRecord,
@@ -1106,11 +1106,13 @@ class BatchExporter:
 
     def _client_kwargs(self) -> dict[str, Any]:
         """Shared httpx.Client construction args for the background and sync
-        clients, so both carry the same base URL, auth header, client-floor
-        check (``client_floor``) and, in tests, injected transport."""
+        clients, so both carry the same base URL, auth header, release
+        ``User-Agent`` (``user_agent``), client-floor check (``client_floor``)
+        and, in tests, injected transport."""
         kwargs: dict[str, Any] = {
             "base_url": self._config.endpoint,
             "headers": {
+                **user_agent.headers(),
                 "X-API-Key": self._config.api_key,
                 "Content-Type": "application/json",
             },

cmpnd-0.86.0/ingest/cmpnd_ingest/user_agent.py

@@ -0,0 +1,52 @@
+"""The ``User-Agent`` every client the SDK builds sends, so the server can count releases.
+
+The value names the installed distribution first, then the runtime it runs on:
+
+    cmpnd/0.85.2 python/3.12.13 httpx/0.28.1 dspy/3.4.1
+
+The first product is ``cmpnd`` for the SDK and ``cmpnd-ingest`` for a producer that
+installs only the transport, so the two never count as one. A distribution that is not
+installed, such as ``dspy`` for a transport-only producer, is left out. A value that
+cannot be read becomes ``unknown`` rather than failing a request.
+"""
+
+from __future__ import annotations
+
+import functools
+import importlib.metadata
+import platform
+
+# The distributions that provide this package, in the order the first one found names
+# the client. Only one is installed at a time (ingest/README.md).
+_CLIENTS = ("cmpnd", "cmpnd-ingest")
+# Runtime libraries whose version shapes what a client sends.
+_LIBRARIES = ("httpx", "dspy")
+
+
+def _version(distribution: str) -> str | None:
+    """The installed version, or None when it is not installed or cannot be read.
+
+    Any failure to read metadata counts as absent, because a broken install's
+    metadata must not stop a client from being built.
+    """
+    try:
+        return importlib.metadata.version(distribution)
+    except Exception:
+        return None
+
+
+@functools.cache
+def user_agent() -> str:
+    """The ``User-Agent`` header value for this process."""
+    client = next(
+        (f"{name}/{version}" for name in _CLIENTS if (version := _version(name)) is not None),
+        "cmpnd/unknown",
+    )
+    products = [client, f"python/{platform.python_version()}"]
+    products += [f"{name}/{version}" for name in _LIBRARIES if (version := _version(name)) is not None]
+    return " ".join(products)
+
+
+def headers() -> dict[str, str]:
+    """The headers that identify this client, to merge into a client's own."""
+    return {"User-Agent": user_agent()}

{cmpnd-0.85.1 → cmpnd-0.86.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.85.1"
+version = "0.86.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.85.1 → cmpnd-0.86.0}/tests/test_cli/test_admin.py

@@ -360,20 +360,61 @@ class TestAdminPlans:
         assert args.func(mock_client, args) == {"plans": []}
         mock_client.get.assert_called_once_with("/api/v1/admin/plans")
 
-    def test_set_limit_and_none(self, mock_client):
-        args = _parse("plans", "limits", "update", "pro", "optimizations.concurrent", "5")
+    def test_draft_update_writes_the_draft_and_none_sends_null(self, mock_client):
+        args = _parse("plans", "draft", "update", "pro", "optimizations.concurrent", "5")
         args.func(mock_client, args)
-        mock_client.put.assert_called_with("/api/v1/admin/plans/pro/limits/optimizations.concurrent", json={"value": 5})
-        args = _parse("plans", "limits", "update", "free", "optimizations.concurrent", "none")
+        mock_client.put.assert_called_with(
+            "/api/v1/admin/plans/pro/draft/limits/optimizations.concurrent", json={"value": 5}
+        )
+        args = _parse("plans", "draft", "update", "free", "optimizations.concurrent", "none")
         args.func(mock_client, args)
         mock_client.put.assert_called_with(
-            "/api/v1/admin/plans/free/limits/optimizations.concurrent", json={"value": None}
+            "/api/v1/admin/plans/free/draft/limits/optimizations.concurrent", json={"value": None}
         )
 
-    def test_clear_limit(self, mock_client):
-        args = _parse("plans", "limits", "delete", "pro", "optimizations.concurrent")
+    def test_draft_delete(self, mock_client):
+        args = _parse("plans", "draft", "delete", "pro", "optimizations.concurrent")
+        args.func(mock_client, args)
+        mock_client.delete.assert_called_once_with("/api/v1/admin/plans/pro/draft/limits/optimizations.concurrent")
+
+    def test_draft_publish_sends_the_note(self, mock_client):
+        mock_client.post.return_value = {"plan": "pro", "version": 2}
+        args = _parse("plans", "draft", "publish", "pro", "--note", "Five at a time")
+        assert args.func(mock_client, args) == {"plan": "pro", "version": 2}
+        mock_client.post.assert_called_once_with(
+            "/api/v1/admin/plans/pro/draft/publish", json={"note": "Five at a time"}
+        )
+        args = _parse("plans", "draft", "publish", "free")
+        args.func(mock_client, args)
+        mock_client.post.assert_called_with("/api/v1/admin/plans/free/draft/publish", json={"note": ""})
+
+    def test_move_by_version_or_by_org(self, mock_client):
+        mock_client.post.return_value = {"plan": "pro", "version": 2, "moved": 3}
+        args = _parse("plans", "move", "pro", "2", "--from-version", "1")
+        assert args.func(mock_client, args)["moved"] == 3
+        mock_client.post.assert_called_with("/api/v1/admin/plans/pro/versions/2/move", json={"from_version": 1})
+        args = _parse("plans", "move", "pro", "2", "--org", "o_1")
         args.func(mock_client, args)
-        mock_client.delete.assert_called_once_with("/api/v1/admin/plans/pro/limits/optimizations.concurrent")
+        mock_client.post.assert_called_with("/api/v1/admin/plans/pro/versions/2/move", json={"org_id": "o_1"})
+
+    def test_move_needs_exactly_one_source_and_a_whole_version(self):
+        import pytest
+
+        for argv in (
+            ("plans", "move", "pro", "2"),
+            ("plans", "move", "pro", "2", "--from-version", "1", "--org", "o_1"),
+            ("plans", "move", "pro", "two", "--org", "o_1"),
+            ("plans", "move", "pro", "0", "--org", "o_1"),
+            ("plans", "move", "pro", "2", "--from-version", "zero"),
+        ):
+            with pytest.raises(SystemExit):
+                _parse(*argv)
+
+    def test_the_in_place_limit_commands_are_gone(self):
+        import pytest
+
+        with pytest.raises(SystemExit):
+            _parse("plans", "limits", "update", "pro", "optimizations.concurrent", "5")
 
     def test_set_flag_enables_by_default_and_disables_with_the_flag(self, mock_client):
         args = _parse("plans", "flags", "update", "free", "beta")
@@ -389,10 +430,10 @@ class TestAdminPlans:
         mock_client.delete.assert_called_once_with("/api/v1/admin/plans/free/feature-flags/beta")
 
     def test_plan_names_are_serves_to_check(self, mock_client):
-        args = _parse("plans", "limits", "update", "platinum", "optimizations.concurrent", "5")
+        args = _parse("plans", "draft", "update", "platinum", "optimizations.concurrent", "5")
         args.func(mock_client, args)
         mock_client.put.assert_called_once_with(
-            "/api/v1/admin/plans/platinum/limits/optimizations.concurrent", json={"value": 5}
+            "/api/v1/admin/plans/platinum/draft/limits/optimizations.concurrent", json={"value": 5}
         )
 
 

cmpnd-0.86.0/tests/test_user_agent.py

@@ -0,0 +1,109 @@
+"""Every client the SDK builds names its release in ``User-Agent``, so the server can
+count which releases are in use.
+
+Driven over real ``httpx.Client`` instances with ``MockTransport``: the property is
+what reaches the wire.
+"""
+
+from __future__ import annotations
+
+import platform
+from collections.abc import Iterator
+
+import httpx
+import pytest
+from cmpnd_ingest import user_agent
+
+import cmpnd
+from cmpnd import _http
+from cmpnd.configuration import Config
+from cmpnd.exporter import BatchExporter
+
+
+@pytest.fixture(autouse=True)
+def _fresh_user_agent() -> Iterator[None]:
+    user_agent.user_agent.cache_clear()
+    yield
+    user_agent.user_agent.cache_clear()
+
+
+def _sent_user_agent(client: httpx.Client, requests: list[httpx.Request]) -> str:
+    with client:
+        client.get("https://app.cmpnd.ai/api/v1/deployments")
+    assert len(requests) == 1
+    return requests[0].headers["User-Agent"]
+
+
+def _capturing(requests: list[httpx.Request]) -> httpx.MockTransport:
+    def handle(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        return httpx.Response(200, json={})
+
+    return httpx.MockTransport(handle)
+
+
+def test_the_user_agent_names_the_release_python_and_libraries() -> None:
+    products = user_agent.user_agent().split(" ")
+    assert products[0] == f"cmpnd/{cmpnd.__version__}"
+    assert products[1] == f"python/{platform.python_version()}"
+    assert f"httpx/{httpx.__version__}" in products
+
+
+def test_an_api_client_sends_the_release_user_agent() -> None:
+    requests: list[httpx.Request] = []
+    sent = _sent_user_agent(_http.new_client(transport=_capturing(requests)), requests)
+    assert sent == user_agent.user_agent()
+    assert sent.startswith(f"cmpnd/{cmpnd.__version__} ")
+
+
+def test_a_callers_own_user_agent_wins() -> None:
+    requests: list[httpx.Request] = []
+    client = _http.new_client(transport=_capturing(requests), headers={"User-Agent": "mine/1"})
+    assert _sent_user_agent(client, requests) == "mine/1"
+
+
+@pytest.mark.parametrize("name", ["user-agent", "USER-AGENT"])
+def test_a_callers_user_agent_wins_in_any_case(name: str) -> None:
+    requests: list[httpx.Request] = []
+    client = _http.new_client(transport=_capturing(requests), headers={name: "mine/1"})
+    _sent_user_agent(client, requests)
+    assert requests[0].headers.get_list("User-Agent") == ["mine/1"]
+
+
+def test_a_callers_httpx_headers_win() -> None:
+    requests: list[httpx.Request] = []
+    client = _http.new_client(transport=_capturing(requests), headers=httpx.Headers({"User-Agent": "mine/1"}))
+    _sent_user_agent(client, requests)
+    assert requests[0].headers.get_list("User-Agent") == ["mine/1"]
+
+
+def test_the_exporter_sends_the_release_user_agent() -> None:
+    requests: list[httpx.Request] = []
+    exporter = BatchExporter(Config(api_key="k", endpoint="http://localhost:9999"), transport=_capturing(requests))
+    sent = _sent_user_agent(httpx.Client(**exporter._client_kwargs()), requests)
+    assert sent == user_agent.user_agent()
+    assert requests[0].headers["X-API-Key"] == "k"
+
+
+def test_a_transport_only_producer_names_itself(monkeypatch: pytest.MonkeyPatch) -> None:
+    versions = {"cmpnd-ingest": "0.1.0", "httpx": "0.28.1"}
+    monkeypatch.setattr(user_agent, "_version", versions.get)
+    assert user_agent.user_agent() == f"cmpnd-ingest/0.1.0 python/{platform.python_version()} httpx/0.28.1"
+
+
+def test_an_unreadable_release_still_sends_a_user_agent(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(user_agent, "_version", lambda _name: None)
+    assert user_agent.user_agent() == f"cmpnd/unknown python/{platform.python_version()}"
+
+
+def test_unreadable_metadata_still_builds_both_clients(monkeypatch: pytest.MonkeyPatch) -> None:
+    def broken(_name: str) -> str:
+        raise OSError("metadata unreadable")
+
+    monkeypatch.setattr(user_agent.importlib.metadata, "version", broken)
+    requests: list[httpx.Request] = []
+    expected = f"cmpnd/unknown python/{platform.python_version()}"
+    assert _sent_user_agent(_http.new_client(transport=_capturing(requests)), requests) == expected
+    requests.clear()
+    exporter = BatchExporter(Config(api_key="k", endpoint="http://localhost:9999"), transport=_capturing(requests))
+    assert _sent_user_agent(httpx.Client(**exporter._client_kwargs()), requests) == expected

{cmpnd-0.85.1 → cmpnd-0.86.0}/uv.lock

@@ -505,7 +505,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.85.1"
+version = "0.86.0"
 source = { editable = "." }
 default-groups = ["dspy-3-4-1"]
 dependencies = [