cmpnd 0.20.0__tar.gz → 0.22.0__tar.gz

{cmpnd-0.20.0 → cmpnd-0.22.0}/PKG-INFO

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

{cmpnd-0.20.0 → cmpnd-0.22.0}/cmpnd/callback.py

@@ -91,31 +91,182 @@ def _dspy_declares_hook(name: str) -> bool:
     return callable(getattr(base, name, None))
 
 
-def _cached_prompt_tokens(usage: Any) -> int:
-    """Read the provider-side prompt-cache read count off a LiteLLM usage dict.
-
-    Providers report cached input tokens two ways: the OpenAI/LiteLLM-normalized
-    ``prompt_tokens_details.cached_tokens``, or a native ``cache_read_input_tokens``
-    (Anthropic). We normalize to a single count that is always a subset of
-    ``prompt_tokens`` — in the LiteLLM-normalized usage the SDK captures,
-    ``prompt_tokens`` already includes the cached reads, so the subset invariant
-    holds. ``prompt_tokens_details`` may be a dict or a small object, so both are
-    handled. Returns 0 when nothing cache-related is present.
+def _usage_field(usage: Any, key: str) -> Any:
+    """Read ``key`` off a usage block, whichever kind of object it is.
+
+    A usage block reaches us as a plain dict (DSPy's legacy history stores
+    ``dict(response.usage)``), as a LiteLLM usage object that also answers
+    ``.get``, or as DSPy's typed ``LMUsage`` pydantic model, which answers only
+    attribute access. All three have to work, so all three are tried.
+    """
+    if usage is None:
+        return None
+    if isinstance(usage, dict):
+        return usage.get(key)
+    getter = getattr(usage, "get", None)
+    if callable(getter):
+        try:
+            return getter(key)
+        except (TypeError, KeyError):
+            pass
+    return getattr(usage, key, None)
+
+
+def _usage_detail(usage: Any, container: str, key: str) -> Any:
+    """Read ``container.key`` off a usage block's nested detail object.
+
+    The detail blocks (``prompt_tokens_details`` and its Responses-API twin)
+    arrive as a dict or as a small object depending on the provider and the
+    LiteLLM version, so both are read.
     """
-    if not usage:
-        return 0
-    details = usage.get("prompt_tokens_details") if hasattr(usage, "get") else None
-    cached = None
+    details = _usage_field(usage, container)
     if isinstance(details, dict):
-        cached = details.get("cached_tokens")
-    elif details is not None:
-        cached = getattr(details, "cached_tokens", None)
-    if not cached and hasattr(usage, "get"):
-        cached = usage.get("cache_read_input_tokens")
-    try:
-        return int(cached) if cached else 0
-    except (TypeError, ValueError):
-        return 0
+        return details.get(key)
+    if details is None:
+        return None
+    return getattr(details, key, None)
+
+
+def _reported_count(*candidates: Any) -> int | None:
+    """Reduce one count's several spellings to the number the provider reported.
+
+    Returns the first nonzero spelling; ``0`` when a spelling reported zero and
+    no other reported a count; ``None`` when no spelling reported at all. The
+    distinction is the point: a provider that says nothing about reasoning
+    tokens and one that reports none of them are different facts. Absent is not
+    zero, and the two stay apart all the way to the UI — a count nobody measured
+    must never be presented as one that was.
+
+    Preferring a nonzero spelling over an earlier zero is what makes the
+    Anthropic pair work: LiteLLM fills ``prompt_tokens_details.cached_tokens``
+    with a 0 alongside a populated native ``cache_read_input_tokens``.
+    """
+    saw_zero = False
+    for candidate in candidates:
+        if candidate is None:
+            continue
+        try:
+            value = int(candidate)
+        except (TypeError, ValueError):
+            continue
+        if value:
+            return value
+        saw_zero = True
+    return 0 if saw_zero else None
+
+
+def _normalize_usage(usage: Any) -> dict[str, int | None]:
+    """Normalize any usage block DSPy can hand us into cmpnd's span counts.
+
+    The one place the SDK reads a provider's usage, because there are three
+    shapes and reading them at each call site is what recorded zero prompt and
+    completion tokens on every Responses-API span, next to a nonzero total:
+
+    * **chat raw** — ``prompt_tokens`` / ``completion_tokens`` /
+      ``total_tokens``, ``prompt_tokens_details.cached_tokens``,
+      ``completion_tokens_details.reasoning_tokens``.
+    * **Responses raw** — ``input_tokens`` / ``output_tokens`` /
+      ``total_tokens``, ``input_tokens_details.cached_tokens``,
+      ``output_tokens_details.reasoning_tokens``. A stock ``dspy.LM`` routes
+      through the legacy contract, whose history entry stores the provider's
+      block verbatim, so this shape arrives unnormalized.
+    * **DSPy typed ``LMUsage``** — fills both name pairs and carries top-level
+      ``reasoning_tokens`` / ``cache_read_tokens`` / ``cache_write_tokens``.
+
+    Anthropic's native ``cache_read_input_tokens`` and
+    ``cache_creation_input_tokens`` ride along on the raw paths.
+
+    ``prompt_tokens``, ``completion_tokens``, ``total_tokens`` and
+    ``cached_prompt_tokens`` come back as counts (0 when unreported — the
+    columns behind them are ``NOT NULL``). ``reasoning_tokens`` and
+    ``cache_write_tokens`` come back as ``None`` when the provider said nothing.
+    """
+    prompt = _reported_count(
+        _usage_field(usage, "prompt_tokens"),
+        _usage_field(usage, "input_tokens"),
+    )
+    completion = _reported_count(
+        _usage_field(usage, "completion_tokens"),
+        _usage_field(usage, "output_tokens"),
+    )
+    total = _reported_count(_usage_field(usage, "total_tokens"))
+    if total is None and (prompt is not None or completion is not None):
+        # Derived only where the provider omitted it — a reported total is
+        # evidence and stays as sent, even when the split disagrees with it.
+        total = (prompt or 0) + (completion or 0)
+
+    cached = _reported_count(
+        _usage_detail(usage, "prompt_tokens_details", "cached_tokens"),
+        _usage_detail(usage, "input_tokens_details", "cached_tokens"),
+        _usage_field(usage, "cache_read_tokens"),
+        _usage_field(usage, "cache_read_input_tokens"),
+    )
+    reasoning = _reported_count(
+        _usage_detail(usage, "completion_tokens_details", "reasoning_tokens"),
+        _usage_detail(usage, "output_tokens_details", "reasoning_tokens"),
+        _usage_field(usage, "reasoning_tokens"),
+    )
+    cache_write = _reported_count(
+        _usage_field(usage, "cache_write_tokens"),
+        _usage_field(usage, "cache_creation_input_tokens"),
+    )
+
+    return {
+        "prompt_tokens": prompt or 0,
+        "completion_tokens": completion or 0,
+        "total_tokens": total or 0,
+        # A subset of prompt_tokens: every dialect above counts its cache reads
+        # inside the prompt total, so the subset invariant holds by construction.
+        "cached_prompt_tokens": cached or 0,
+        "reasoning_tokens": reasoning,
+        "cache_write_tokens": cache_write,
+    }
+
+
+def _finish_reason(response: Any) -> str | None:
+    """Read why the model stopped, from whichever response shape answered.
+
+    Chat puts it on a choice. DSPy's typed ``LMResponse`` puts it on an output.
+    The Responses API has neither: it reports a ``status`` plus, when the answer
+    was cut short, an ``incomplete_details.reason``. Those map onto the chat
+    vocabulary, which is what serve's truncation warning reads — a Responses
+    ``max_output_tokens`` and a chat ``length`` are the same fact and must land
+    on the same word.
+
+    Returns ``None`` when the response reports nothing about it.
+    """
+    if response is None:
+        return None
+
+    choices = getattr(response, "choices", None)
+    if choices:
+        reason = getattr(choices[0], "finish_reason", None)
+        if reason:
+            return str(reason)
+
+    outputs = getattr(response, "outputs", None)
+    if isinstance(outputs, list) and outputs:
+        reason = getattr(outputs[0], "finish_reason", None)
+        if reason:
+            return str(reason)
+
+    incomplete = getattr(response, "incomplete_details", None)
+    reason = incomplete.get("reason") if isinstance(incomplete, dict) else getattr(incomplete, "reason", None)
+    if reason:
+        return "length" if reason == "max_output_tokens" else str(reason)
+
+    status = getattr(response, "status", None)
+    if not isinstance(status, str) or not status:
+        return None
+    if status != "completed":
+        # "failed", "in_progress" — recorded as reported rather than guessed at.
+        return status
+    items = getattr(response, "output", None) or []
+    for item in items:
+        kind = item.get("type") if isinstance(item, dict) else getattr(item, "type", None)
+        if kind == "function_call":
+            return "tool_calls"
+    return "stop"
 
 
 class _CallbackBase:
@@ -512,7 +663,6 @@ class _ModuleMixin(_CallbackBase):
 
                 exp = exporter.get_exporter()
                 if exp:
-                    exp.export_trace_stats(trace)  # Stats tier (lightweight, never dropped)
                     if trace.streaming:
                         exp.export_trace_finalize(trace)  # Finalize the streaming trace
                     else:
@@ -734,15 +884,30 @@ class _ModuleMixin(_CallbackBase):
         return trace
 
     def _extract_usage_from_prediction(self, span: models.SpanBuilder, outputs: Any, dspy: Any) -> None:
-        """Extract token usage from a DSPy Prediction."""
-        if isinstance(outputs, dspy.Prediction):
-            usage_by_model = outputs.get_lm_usage() if hasattr(outputs, "get_lm_usage") else None
-            if usage_by_model:
-                for model_usage in usage_by_model.values():
-                    span.prompt_tokens += model_usage.get("prompt_tokens", 0)
-                    span.completion_tokens += model_usage.get("completion_tokens", 0)
-                    span.total_tokens += model_usage.get("total_tokens", 0)
-                    span.cached_prompt_tokens += _cached_prompt_tokens(model_usage)
+        """Sum the LM usage a DSPy Prediction carries onto its module span.
+
+        This is what fills the trace row's own token totals, so a shape read
+        wrongly here reports a trace as having spent no tokens even when the LM
+        spans below it carry the right counts.
+        """
+        if not isinstance(outputs, dspy.Prediction):
+            return
+        usage_by_model = outputs.get_lm_usage() if hasattr(outputs, "get_lm_usage") else None
+        if not usage_by_model:
+            return
+        for model_usage in usage_by_model.values():
+            counts = _normalize_usage(model_usage)
+            span.prompt_tokens += counts["prompt_tokens"] or 0
+            span.completion_tokens += counts["completion_tokens"] or 0
+            span.total_tokens += counts["total_tokens"] or 0
+            span.cached_prompt_tokens += counts["cached_prompt_tokens"] or 0
+            # Summed only over the models that reported one, so a span whose
+            # models all stayed silent keeps the field absent rather than 0.
+            for name in ("reasoning_tokens", "cache_write_tokens"):
+                reported = counts[name]
+                if reported is None:
+                    continue
+                setattr(span, name, (getattr(span, name) or 0) + reported)
 
 
 class _LMMixin(_CallbackBase):
@@ -841,11 +1006,13 @@ class _LMMixin(_CallbackBase):
                 usage = outputs.get("usage", {})
 
             if usage:
-                span.prompt_tokens = usage.get("prompt_tokens", 0)
-                span.completion_tokens = usage.get("completion_tokens", 0)
-                span.total_tokens = usage.get("total_tokens", 0)
-                span.cached_prompt_tokens = _cached_prompt_tokens(usage)
-                span.cost = helpers.compute_cost(span.model_name or "", span.prompt_tokens, span.completion_tokens)
+                counts = _normalize_usage(usage)
+                span.prompt_tokens = counts["prompt_tokens"] or 0
+                span.completion_tokens = counts["completion_tokens"] or 0
+                span.total_tokens = counts["total_tokens"] or 0
+                span.cached_prompt_tokens = counts["cached_prompt_tokens"] or 0
+                span.reasoning_tokens = counts["reasoning_tokens"]
+                span.cache_write_tokens = counts["cache_write_tokens"]
                 logger.debug(f"LM usage captured: {span.total_tokens} tokens")
             else:
                 logger.debug(f"NO usage data for {span.model_name} (call_id={call_id})")
@@ -854,11 +1021,9 @@ class _LMMixin(_CallbackBase):
             if instance and hasattr(instance, "history") and instance.history:
                 try:
                     latest_entry = instance.history[-1]
-                    response = latest_entry.get("response")
-                    if response and hasattr(response, "choices") and response.choices:
-                        finish_reason = getattr(response.choices[0], "finish_reason", None)
-                        if finish_reason:
-                            span.set_attribute("lm.finish_reason", finish_reason)
+                    finish_reason = _finish_reason(latest_entry.get("response"))
+                    if finish_reason:
+                        span.set_attribute("lm.finish_reason", finish_reason)
                 except (IndexError, AttributeError, TypeError):
                     pass
 
@@ -906,6 +1071,13 @@ class _LMMixin(_CallbackBase):
             separate judge LM), run during candidate evaluation after the program
             trace has already closed.
 
+        Only a metric that calls the LM **directly** arrives here. A metric that
+        grades through a dspy module opens a trace of its own at that module's
+        boundary, so its LM call has a trace in scope and never reaches this
+        function — it is an ordinary trace, linked to the eval run and named
+        after the grading module. So the two ways of writing a judge take
+        completely different paths through this callback.
+
         We distinguish them by `_active_eval_run` — set only while DSPy Evaluate
         is running — instead of assuming every untraced call is reflection (that
         would mislabel judge calls). The trace is named with the umbrella "GEPA";
@@ -949,7 +1121,6 @@ class _LMMixin(_CallbackBase):
 
         exp = exporter.get_exporter()
         if exp:
-            exp.export_trace_stats(trace)  # stats tier (never dropped)
             trace._batch_spans = [span]
             exp.export_trace(trace)
 

{cmpnd-0.20.0 → cmpnd-0.22.0}/cmpnd/eval_handler.py

@@ -260,13 +260,27 @@ class EvalHandler:
             elif isinstance(outputs, tuple) and len(outputs) >= 2:
                 results = outputs[1] if isinstance(outputs[1], list) else []
 
-            # Get collected traces for this eval run (in execution order)
+            # Every trace this eval run collected, in execution order. The order
+            # matters only for _last_eval_trace_ids below — examples are matched
+            # by identity, never by position (see traces_by_id).
             eval_run_id = str(eval_run.eval_run_id)
             eval_traces = self._eval_traces.get(eval_run_id, [])
-            # Sort traces by start_time to ensure correct ordering
             _min_time = datetime.min.replace(tzinfo=timezone.utc)
             eval_traces.sort(key=lambda t: t.start_time or _min_time)
 
+            # A metric that asks a model to grade the answer makes its call
+            # after the program's own trace has closed, so the grader opens a
+            # trace of its own and this list holds roughly twice as many traces
+            # as there are results. Handing result N the Nth trace therefore
+            # gives an example whichever run happened to sort into its slot —
+            # the grader's tokens, the grader's cost and a trace link pointing
+            # at a grading call. The callback stamps each returned Prediction
+            # with the trace id of the run that produced it, so that stamp —
+            # not a position — is what a result is matched on.
+            traces_by_id = {str(t.trace_id): t for t in eval_traces}
+            # Imported here, not at module scope: callback imports eval_handler.
+            from . import callback as callback_module
+
             logger.debug(f"Collected {len(eval_traces)} traces for eval run")
             for i, t in enumerate(eval_traces[:3]):  # Show first 3
                 logger.debug(f"  Trace {i}: tokens={t.total_tokens}, cost={t.total_cost}")
@@ -322,9 +336,13 @@ class EvalHandler:
                     # Compute example hash for comparability
                     example_builder.example_hash = identity.compute_example_hash(example_builder.inputs)
 
-                    # Match with trace to get metrics (by index)
-                    if idx < len(eval_traces):
-                        trace = eval_traces[idx]
+                    # Match this result to the run that produced it, by the
+                    # trace id the callback stamped on the prediction. No
+                    # positional fallback: a result carrying no stamp is left
+                    # unlinked, because a wrong trace, a wrong token count and a
+                    # wrong cost are worse than none.
+                    trace = traces_by_id.get(callback_module.trace_id(prediction) or "")
+                    if trace is not None:
                         example_builder.trace_id = trace.trace_id
 
                         # Extract duration from trace
@@ -335,6 +353,8 @@ class EvalHandler:
                         # Extract tokens and cost from trace
                         example_builder.total_tokens = trace.total_tokens
                         example_builder.cost = trace.total_cost
+                    else:
+                        logger.debug(f"Eval example {idx} carries no trace stamp; left unattributed")
 
                 eval_run.add_example_result(example_builder)
 

{cmpnd-0.20.0 → cmpnd-0.22.0}/cmpnd/helpers.py

@@ -126,31 +126,3 @@ def infer_provider(instance: Any) -> str:
         return "together"
     else:
         return "unknown"
-
-
-# Simple cost table for common models ($/1M tokens)
-# (input_cost_per_1m, output_cost_per_1m)
-_MODEL_COSTS: dict[str, tuple[float, float]] = {
-    "gpt-4o": (2.50, 10.00),
-    "gpt-4o-mini": (0.15, 0.60),
-    "gpt-4-turbo": (10.00, 30.00),
-    "gpt-4": (30.00, 60.00),
-    "gpt-3.5-turbo": (0.50, 1.50),
-    "claude-3-5-sonnet-20241022": (3.00, 15.00),
-    "claude-sonnet-4-20250514": (3.00, 15.00),
-    "claude-3-5-haiku-20241022": (0.80, 4.00),
-    "claude-haiku-4-5-20251001": (0.80, 4.00),
-    "claude-3-opus-20240229": (15.00, 75.00),
-    "claude-opus-4-20250514": (15.00, 75.00),
-}
-
-
-def compute_cost(model_name: str, prompt_tokens: int, completion_tokens: int) -> float:
-    """Compute cost from model name and token counts."""
-    if not model_name or (prompt_tokens == 0 and completion_tokens == 0):
-        return 0.0
-    costs = _MODEL_COSTS.get(model_name)
-    if not costs:
-        return 0.0
-    input_cost, output_cost = costs
-    return (prompt_tokens * input_cost / 1_000_000) + (completion_tokens * output_cost / 1_000_000)

{cmpnd-0.20.0 → cmpnd-0.22.0}/cmpnd/models.py

@@ -461,6 +461,18 @@ class SpanBuilder:
     # the cached reads — so cached_prompt_tokens <= prompt_tokens holds by
     # construction. 0 means no cache reads (or the provider reported none).
     cached_prompt_tokens: int = 0
+    # Reasoning (thinking) tokens the provider billed inside completion_tokens,
+    # and prompt tokens it charged for WRITING into its prompt cache. Both are
+    # None when the provider reported nothing about them — a call that said
+    # nothing and a call that reported none are different facts, and pricing
+    # treats them differently, so absent must not be flattened into zero.
+    # Normalized by callback._normalize_usage.
+    reasoning_tokens: int | None = None
+    cache_write_tokens: int | None = None
+    # Left unset by the SDK. A dollar figure is a derivation from these counts
+    # and a dated rate catalog, and only serve holds the catalog; the SDK's job
+    # is to report what the provider said. serve still reads the wire field, so
+    # it stays on the model for a producer that does know a price.
     cost: float = 0.0
 
     # DSPy-specific: Demo info
@@ -568,6 +580,8 @@ class SpanBuilder:
             "completion_tokens": self.completion_tokens,
             "total_tokens": self.total_tokens,
             "cached_prompt_tokens": self.cached_prompt_tokens,
+            "reasoning_tokens": self.reasoning_tokens,
+            "cache_write_tokens": self.cache_write_tokens,
             "cost": self.cost,
             "demos": _safe_serialize(self.demos),
             "demo_count": self.demo_count if self.demo_count else len(self.demos),
@@ -728,26 +742,6 @@ class TraceBuilder:
             "project_tags": self.project_tags if self.project_tags else [],
         }
 
-    def to_stats_dict(self) -> dict[str, Any]:
-        """Lightweight stats payload (~200 bytes). Never dropped."""
-        return {
-            "trace_id": str(self.trace_id),
-            "timestamp": self.start_time.isoformat() if self.start_time else None,
-            "program_signature_hash": identity.format_signature_hash(self.program_signature_hash),
-            "program_name": self.program_name or "",
-            "status": self.status.value,
-            "total_tokens": self.total_tokens,
-            "prompt_tokens": self.prompt_tokens,
-            "completion_tokens": self.completion_tokens,
-            "total_cost": self.total_cost,
-            "model_name": "",
-            "eval_run_id": str(self.eval_run_id) if self.eval_run_id else None,
-            "optimization_run_id": (str(self.optimization_run_id) if self.optimization_run_id else None),
-            "span_count": self.span_count,
-            "project": self.project_tags[0] if self.project_tags else None,
-            "project_tags": self.project_tags if self.project_tags else [],
-        }
-
 
 class EvalRunStatus(str, Enum):
     """Evaluation run status."""

{cmpnd-0.20.0 → cmpnd-0.22.0}/docs/2026-04-02-code-review.md

@@ -47,7 +47,6 @@ cmpnd/
    → Aggregate tokens/cost across spans
    → If streaming (RLM): export_trace_start + export_span per child + export_trace_finalize
    → If batching: export_trace with all spans attached
-   → Always: export_trace_stats (lightweight, never dropped)
 
 4. Background exporter thread
    → Collects from queue with timeout

{cmpnd-0.20.0 → cmpnd-0.22.0}/docs/sdk-instrumentation.md

@@ -180,7 +180,7 @@ Override any of these by passing kwargs to `cmpnd.configure(...)`.
 
 - `start()` at `exporter_http.py:131` creates the worker thread and the `ThreadPoolExecutor`, then registers `shutdown()` via `threading._register_atexit` (or `atexit.register` as a fallback). The registration ordering is deliberate — there's a comment at `exporter_http.py:139` explaining why it has to go after the executor init.
 - `_export_loop` at `exporter_http.py:355` pulls from the internal `queue.Queue` with a 100ms timeout, appends to a local batch, and calls `_flush_batch` when `batch_size` or `flush_interval_seconds` trips.
-- `_flush_batch` at `exporter_http.py:443` sorts items by type (`trace`, `span`, `trace_start`, `trace_finalize`, `trace_stats`, `eval_run`, `optimization_run`, various optimization progress records), buffers loose spans keyed by `trace_id` so they can be attached to their parent trace when it arrives, and submits each type's `_send_*` call to the thread pool in parallel.
+- `_flush_batch` at `exporter_http.py:443` sorts items by type (`trace`, `span`, `trace_start`, `trace_finalize`, `eval_run`, `optimization_run`, various optimization progress records), buffers loose spans keyed by `trace_id` so they can be attached to their parent trace when it arrives, and submits each type's `_send_*` call to the thread pool in parallel.
 - `shutdown()` at `exporter_http.py:163` sets the shutdown event, joins the worker thread, drains any leftover queue items, then shuts down the executor and HTTP client. It is safe to call multiple times.
 
 ### Delivery errors, dropping, and transient retry
@@ -400,6 +400,8 @@ The trace payload is built in `python-sdk/cmpnd/models.py` by `TraceBuilder.to_a
     "prompt_tokens": 137,
     "completion_tokens": 42,
     "cached_prompt_tokens": 96,  # provider prompt-cache reads, subset of prompt_tokens
+    "reasoning_tokens": 12,      # subset of completion_tokens; None when unreported
+    "cache_write_tokens": None,  # prompt-cache writes; None when unreported
     "inputs": { ... },
     "outputs": { ... },
     # ...plus status, timings, attributes, events

{cmpnd-0.20.0 → cmpnd-0.22.0}/ingest/cmpnd_ingest/bodies.py

@@ -61,9 +61,6 @@ class TraceBody:
     def to_finalize_dict(self) -> dict[str, Any]:
         return dict(self.payload)
 
-    def to_stats_dict(self) -> dict[str, Any]:
-        return dict(self.payload)
-
 
 @dataclass(frozen=True)
 class SpanBody:

{cmpnd-0.20.0 → cmpnd-0.22.0}/ingest/cmpnd_ingest/exporter_http.py

@@ -180,8 +180,7 @@ class ExportItem:
     """Item in the export queue."""
 
     # item_type: "trace", "span", "eval_run", "optimization_complete",
-    #            "optimization_progress", "trace_start", "trace_finalize",
-    #            or "trace_stats"
+    #            "optimization_progress", "trace_start", or "trace_finalize"
     item_type: str
     # Tag-driven dispatch (item_type → method on data). pyright can't
     # narrow the union across the if/elif chain in _flush_batch, so each
@@ -588,10 +587,6 @@ class BatchExporter:
         """Queue a trace finalization for export (non-blocking)."""
         self._enqueue(ExportItem("trace_finalize", trace, time.time()))
 
-    def export_trace_stats(self, trace: TraceRecord) -> None:
-        """Queue trace stats for export (non-blocking)."""
-        self._enqueue(ExportItem("trace_stats", trace, time.time()))
-
     def export_optimization_start(self, optimization_run: OptimizationRunRecord) -> str:
         """Create the optimization record server-side and return the
         server-assigned ``optimization_run_id``.
@@ -1137,7 +1132,6 @@ class BatchExporter:
         # --- Phase 1: Organize items by type (sequential) ---
 
         traces_to_send: list[dict[str, Any]] = []
-        stats_to_send: list[dict[str, Any]] = []
         eval_runs_to_send: list[dict[str, Any]] = []
         optimization_complete_to_send: list[dict[str, Any]] = []
         optimization_progress_to_send: list[tuple[str, dict[str, Any], OptimizationRunRecord]] = []
@@ -1149,8 +1143,6 @@ class BatchExporter:
         for item in batch:
             if item.item_type == "trace":
                 traces_to_send.append(cast("TraceRecord", item.data).to_api_dict())
-            elif item.item_type == "trace_stats":
-                stats_to_send.append(cast("TraceRecord", item.data).to_stats_dict())
             elif item.item_type == "eval_run":
                 eval_runs_to_send.append(cast("EvalRunRecord", item.data).to_api_dict())
             elif item.item_type == "optimization_complete":
@@ -1237,8 +1229,6 @@ class BatchExporter:
             futures.append(executor.submit(self._send_spans_for_trace, trace_id, span_list))
         if trace_finalizes:
             futures.append(executor.submit(self._send_trace_finalizes, trace_finalizes))
-        if stats_to_send:
-            futures.append(executor.submit(self._send_stats, stats_to_send))
         if eval_runs_to_send:
             futures.append(executor.submit(self._send_eval_runs, eval_runs_to_send))
         if optimization_progress_to_send:
@@ -1368,19 +1358,6 @@ class BatchExporter:
                 with self._stats_lock:
                     self._error_count += 1
 
-    def _send_stats(self, stats_to_send: list[dict[str, Any]]) -> None:
-        client = self._require_client()
-        try:
-            response = self._send_json_retrying(client, "POST", "/api/v1/traces/stats", stats_to_send)
-            response.raise_for_status()
-            with self._stats_lock:
-                self._exported_count += len(stats_to_send)
-            logger.debug(f"Exported {len(stats_to_send)} trace stats")
-        except Exception as e:
-            logger.error(f"Failed to export trace stats: {e}")
-            with self._stats_lock:
-                self._error_count += len(stats_to_send)
-
     def _send_eval_runs(self, eval_runs_to_send: list[dict[str, Any]]) -> None:
         # Completion is a PATCH to the running record created by the
         # synchronous export_eval_start, keyed by the server-assigned id.

{cmpnd-0.20.0 → cmpnd-0.22.0}/ingest/cmpnd_ingest/protocols.py

@@ -49,14 +49,13 @@ class SpanRecord(Protocol):
 
 
 class TraceRecord(Protocol):
-    """A trace, in each of the four shapes the contract's routes take."""
+    """A trace, in each of the three shapes the contract's routes take."""
 
     @property
     def trace_id(self) -> Any: ...
     def to_api_dict(self) -> dict[str, Any]: ...
     def to_start_dict(self) -> dict[str, Any]: ...
     def to_finalize_dict(self) -> dict[str, Any]: ...
-    def to_stats_dict(self) -> dict[str, Any]: ...
 
 
 class EvalRunRecord(Protocol):

{cmpnd-0.20.0 → cmpnd-0.22.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.20.0"
+version = "0.22.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.10"

{cmpnd-0.20.0 → cmpnd-0.22.0}/scripts/capture_review_run.py

@@ -75,8 +75,6 @@ def _kind_for(method: str, path: str, payload) -> tuple[str, object] | None:
             return ("traces_batch", [payload])
         if _SPANS_PATH.match(path):
             return ("spans", payload)
-        if path == "/api/v1/traces/stats":
-            return ("stats", payload)
     elif method == "PUT" and _OPT_COMPLETE_PATH.match(path):
         if isinstance(payload, dict) and payload.get("status") == "running":
             return None

{cmpnd-0.20.0 → cmpnd-0.22.0}/scripts/seed_review_run.py

@@ -815,25 +815,21 @@ def main() -> int:
         _post(endpoint, f"/api/v1/optimizations/{new_op}", opt_payload, api_key, method="PUT")
         log.info("seeded optimization run %s", new_op)
 
-        # 2) Replay its traces / spans / stats, linked to the new run.
-        n_traces = n_spans = n_stats = 0
+        # 2) Replay its traces / spans, linked to the new run.
+        n_traces = n_spans = 0
         for p in parts:
             if p["kind"] == "traces_batch":
                 payload = [_transform(item, uuid_map, delta, new_op, _TAGS_COMPLETE) for item in p["payload"]]
                 _stamp_deployments(payload, dep_for)
                 _post(endpoint, "/api/v1/traces/batch", payload, api_key)
                 n_traces += len(payload)
-            elif p["kind"] == "stats":
-                payload = [_transform(item, uuid_map, delta, new_op, _TAGS_COMPLETE) for item in p["payload"]]
-                _post(endpoint, "/api/v1/traces/stats", payload, api_key)
-                n_stats += len(payload)
             elif p["kind"] == "spans":
                 old = _UUID_RE.search(p["path"])
                 trace_uuid = uuid_map.get(old.group(0), old.group(0)) if old else ""
                 payload = _transform(p["payload"], uuid_map, delta, new_op, _TAGS_COMPLETE)
                 _post(endpoint, f"/api/v1/traces/{trace_uuid}/spans", payload, api_key)
                 n_spans += 1
-        log.info("seeded %d traces, %d span-batches, %d stat rows -> %s", n_traces, n_spans, n_stats, new_op)
+        log.info("seeded %d traces, %d span-batches -> %s", n_traces, n_spans, new_op)
 
         # 2b) Pin the completed committee program for the demo admin (CMP-634) so
         # the sidebar shows a pinned program. Runs now that the trace ingest has
@@ -872,11 +868,6 @@ def main() -> int:
                         payload = [_transform(item, umap, delta, running_op, _TAGS_RUNNING) for item in kept]
                         _post(endpoint, "/api/v1/traces/batch", payload, api_key)
                         n_it += len(payload)
-                elif p["kind"] == "stats":
-                    kept = [s for s in p["payload"] if s.get("trace_id") in keep]
-                    if kept:
-                        payload = [_transform(item, umap, delta, running_op, _TAGS_RUNNING) for item in kept]
-                        _post(endpoint, "/api/v1/traces/stats", payload, api_key)
                 elif p["kind"] == "spans":
                     old = _UUID_RE.search(p["path"])
                     if old and old.group(0) in keep: