metergraphrelay 0.7.1__tar.gz → 0.7.2__tar.gz

{metergraphrelay-0.7.1/src/metergraphrelay.egg-info → metergraphrelay-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraphrelay
-Version: 0.7.1
+Version: 0.7.2
 Summary: Move LLM trace data between systems: pull from providers, push to metergraph.
 Author: Vasiliy Radostev
 License-Expression: MIT
@@ -551,6 +551,9 @@ records**, the run splits it **once** into **10 sub-windows with
 absorbs the boundary overlaps). This split is one-shot, never recursive:
 if any single sub-window *still* exceeds 50,000 records, the run fails
 with a clear error rather than splitting further.
+Before splitting, the run cancels the never-started hourly draft on a best effort
+basis. If Portkey refuses the cancel, the run warns and continues because an
+unstarted draft only counts rows and exports nothing.
 
 **Before running this against your own data:** as in manual mode,
 request and response content is uploaded to metergraph, with no opt-out.

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/README.md

@@ -528,6 +528,9 @@ records**, the run splits it **once** into **10 sub-windows with
 absorbs the boundary overlaps). This split is one-shot, never recursive:
 if any single sub-window *still* exceeds 50,000 records, the run fails
 with a clear error rather than splitting further.
+Before splitting, the run cancels the never-started hourly draft on a best effort
+basis. If Portkey refuses the cancel, the run warns and continues because an
+unstarted draft only counts rows and exports nothing.
 
 **Before running this against your own data:** as in manual mode,
 request and response content is uploaded to metergraph, with no opt-out.

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "metergraphrelay"
-version = "0.7.1"
+version = "0.7.2"
 description = "Move LLM trace data between systems: pull from providers, push to metergraph."
 readme = "README.md"
 requires-python = ">=3.10"

metergraphrelay-0.7.2/src/metergraphrelay/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.2"

metergraphrelay-0.7.2/src/metergraphrelay/billing_evidence.py

@@ -0,0 +1,43 @@
+"""How an importer states where a cost figure came from.
+
+metergraph selects an effective cost from its own catalog and from amounts a
+source reported. It can only weigh a reported amount if it knows what produced
+it, because the field carrying one is open: a figure a customer's own client
+wrote and a figure a gateway billed arrive in the same place and look alike.
+
+Two kinds of source report a cost, and they are not equivalent:
+
+* A **gateway** sits in the request path and states what the call cost. Naming
+  it lets that amount be treated as billing evidence.
+* An **observability platform** reports its own estimate, computed from the
+  tokens it observed against a price table it maintains. Braintrust calls the
+  field ``estimated_cost``, which is the honest description of all of them.
+
+So an observability platform names its source and no gateway, while a gateway
+states itself on the row. The amount is still recorded either way, and an audit
+can compare it against a computed cost, but nothing can mistake an estimate for
+something the provider charged.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal, InvalidOperation
+from typing import Any
+
+
+def reported_cost(amount: Any, *, source: str) -> dict:
+    """The fields naming a reported cost, or nothing when there is no amount.
+
+    The amount is carried as a decimal string. A cost lands in a numeric column,
+    and a value divided or parsed as a binary float arrives carrying rounding
+    that no later step can remove.
+    """
+    if amount is None or isinstance(amount, bool):
+        return {}
+    try:
+        parsed = Decimal(str(amount))
+    except (InvalidOperation, TypeError, ValueError):
+        return {}
+    if not parsed.is_finite() or parsed < 0:
+        return {}
+    return {"reported_cost_usd": str(parsed), "reported_cost_source": source}

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/portkey_sync.py

@@ -26,6 +26,7 @@ boundaries force an unconditional renewal.
 from __future__ import annotations
 
 import os
+import sys
 import tempfile
 import time
 from typing import Callable
@@ -182,9 +183,9 @@ def run_portkey_sync(
 def _plan_exports(pk_client, lease, created_export_ids: list[str], renewer) -> list[str]:
     """Create the hourly draft; its ``total`` decides whether to split. No start/poll here.
 
-    ``total > threshold`` cancels the still-unstarted hourly draft and creates
-    exactly 10 overlapping sub-window drafts. If any sub-window draft is itself
-    still oversized, reject with a clear error — the MVP never splits recursively.
+    ``total > threshold`` best-effort cancels the still-unstarted hourly draft and
+    creates exactly 10 overlapping sub-window drafts. If any sub-window draft is
+    itself still oversized, reject with a clear error — the MVP never splits recursively.
     Each create/cancel can be slow, so the lease is renewed on a time cadence
     between them.
     """
@@ -196,8 +197,16 @@ def _plan_exports(pk_client, lease, created_export_ids: list[str], renewer) -> l
     if hourly.total is None or hourly.total <= VOLUME_SPLIT_THRESHOLD:
         return [hourly.export_id]
 
-    # Oversized: cancel the still-unstarted hourly draft, then split into exactly 10.
-    pk_client.cancel_export(hourly.export_id)
+    # Oversized: best-effort cancel the still-unstarted hourly draft, then split into
+    # exactly 10. An unstarted draft costs nothing, so a cancel refusal is non-fatal.
+    try:
+        pk_client.cancel_export(hourly.export_id)
+    except (PortkeyExportError, OSError) as exc:
+        print(
+            f"Warning: could not cancel export {hourly.export_id}: {exc}; the draft "
+            "was never started so it is left in place.",
+            file=sys.stderr,
+        )
     created_export_ids.remove(hourly.export_id)
     renewer.tick()
     # split_window validates the server-provided bounds (aware, end-after-start). A

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/braintrust.py

@@ -9,6 +9,7 @@ import urllib.request
 from typing import Any, Callable
 
 from .. import __version__
+from ..billing_evidence import reported_cost
 from ..capture_contract import capture_response_text, capture_row, capture_tool_calls
 from ..import_identity import ImportContext, canonical_import_event_id
 from ..window import normalize_utc_designator
@@ -513,6 +514,7 @@ def normalize_span(
         "reasoning_tokens": usage["reasoning_tokens"],
         "latency_ms": usage["latency_ms"],
         "cost_usd": _cost_usd(span, metrics),
+        **reported_cost(_cost_usd(span, metrics), source="braintrust.estimated_cost"),
         "error": error,
         "error_type": _error_type(raw_error) if error else None,
         "request_id": span["id"],

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/langfuse.py

@@ -11,6 +11,7 @@ import urllib.request
 from typing import Any, Callable
 
 from .. import __version__
+from ..billing_evidence import reported_cost
 from ..capture_contract import capture_response_text, capture_row
 from ..import_identity import ImportContext, canonical_import_event_id
 
@@ -297,6 +298,19 @@ _REASONING_KEYS = (
 )
 _NON_BUCKET_MARKERS = ("priority",)
 
+# Providers whose own usage reports input *excluding* the cached tokens, which
+# it lists separately. metergraph prices cache handling per publisher, so a row
+# has to arrive in the shape that publisher's API uses: for one of these,
+# folding the cache buckets into input makes those tokens part of the input
+# total as well as a bucket of their own, and they are billed twice -- once at
+# the input rate and once at the cache rate, an order of magnitude apart.
+#
+# For OpenAI and Google the opposite is true: their own totals include the
+# cached tokens, so the buckets Langfuse subtracted do have to be added back.
+_CACHE_EXCLUSIVE_INPUT_PROVIDERS = frozenset(
+    {"anthropic", "bedrock", "aws-bedrock", "aws", "amazon-bedrock"}
+)
+
 
 def _is_int(value: Any) -> bool:
     return isinstance(value, int) and not isinstance(value, bool)
@@ -315,17 +329,26 @@ def _first_int(source: dict[str, Any], keys: tuple[str, ...]) -> int | None:
 
 
 def _total_with_buckets(
-    usage_details: dict[str, Any], total_keys: tuple[str, ...], marker: str
+    usage_details: dict[str, Any],
+    total_keys: tuple[str, ...],
+    marker: str,
+    *,
+    skip_keys: tuple[str, ...] = (),
 ) -> int | None:
-    """The named total plus every other integer bucket carrying ``marker``."""
+    """The named total plus every other integer bucket carrying ``marker``.
+
+    ``skip_keys`` names buckets the total already excludes by the provider's own
+    convention, so adding them would count those tokens twice.
+    """
     total_key, total = _first_int_key(usage_details, total_keys)
     if total_key is None:
         return None
+    skipped = {key.lower() for key in skip_keys}
     for key, value in usage_details.items():
         if key == total_key or not _is_int(value):
             continue
         lowered = key.lower()
-        if marker not in lowered:
+        if marker not in lowered or lowered in skipped:
             continue
         if any(skip in lowered for skip in _NON_BUCKET_MARKERS):
             continue
@@ -333,8 +356,15 @@ def _total_with_buckets(
     return total
 
 
-def map_usage_details(usage_details: Any) -> dict[str, int | None]:
-    """Map one observation's usageDetails onto metergraph token fields."""
+def map_usage_details(
+    usage_details: Any, *, provider: str | None = None
+) -> dict[str, int | None]:
+    """Map one observation's usageDetails onto metergraph token fields.
+
+    ``provider`` decides whether the cache buckets belong inside the input
+    total, because that is a property of the provider's own usage shape rather
+    than of Langfuse's.
+    """
     if not isinstance(usage_details, dict):
         return {
             "input_tokens": None,
@@ -343,8 +373,16 @@ def map_usage_details(usage_details: Any) -> dict[str, int | None]:
             "cache_write_tokens": None,
             "reasoning_tokens": None,
         }
+    cache_exclusive = (
+        str(provider or "").strip().lower() in _CACHE_EXCLUSIVE_INPUT_PROVIDERS
+    )
     return {
-        "input_tokens": _total_with_buckets(usage_details, _INPUT_TOTAL_KEYS, "input"),
+        "input_tokens": _total_with_buckets(
+            usage_details,
+            _INPUT_TOTAL_KEYS,
+            "input",
+            skip_keys=(_CACHE_READ_KEYS + _CACHE_WRITE_KEYS) if cache_exclusive else (),
+        ),
         "output_tokens": _total_with_buckets(usage_details, _OUTPUT_TOTAL_KEYS, "output"),
         "cache_read_tokens": _first_int(usage_details, _CACHE_READ_KEYS),
         "cache_write_tokens": _first_int(usage_details, _CACHE_WRITE_KEYS),
@@ -382,7 +420,8 @@ def normalize_observation(
         raw_status_message if error and isinstance(raw_status_message, str) else None
     )
 
-    usage = map_usage_details(observation.get("usageDetails"))
+    provider = infer_provider(observation)
+    usage = map_usage_details(observation.get("usageDetails"), provider=provider)
     request_json, request_text = _map_content(observation.get("input"))
     response_text = _response_text(observation.get("output"))
 
@@ -393,7 +432,7 @@ def normalize_observation(
         "source": "langfuse",
         "sdk": "metergraphrelay",
         "sdk_version": __version__,
-        "provider": infer_provider(observation),
+        "provider": provider,
         "model": model,
         "status": "error" if error else "success",
         "input_tokens": usage["input_tokens"],
@@ -402,6 +441,7 @@ def normalize_observation(
         "cache_write_tokens": usage["cache_write_tokens"],
         "reasoning_tokens": usage["reasoning_tokens"],
         "cost_usd": observation.get("totalCost"),
+        **reported_cost(observation.get("totalCost"), source="langfuse.observation.totalCost"),
         "error": error,
         "error_type": error_type,
         "request_id": observation["id"],

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/langsmith.py

@@ -39,6 +39,7 @@ from datetime import datetime
 from typing import Any, Callable
 
 from .. import __version__
+from ..billing_evidence import reported_cost
 from ..capture_contract import capture_response_text, capture_row
 from ..import_identity import ImportContext, canonical_import_event_id
 from ..window import normalize_utc_designator
@@ -473,6 +474,7 @@ def normalize_run(
         "reasoning_tokens": usage["reasoning_tokens"],
         "latency_ms": _latency_ms(run.get("start_time"), run.get("end_time")),
         "cost_usd": _cost_usd(run),
+        **reported_cost(_cost_usd(run), source="langsmith.total_cost"),
         "error": error,
         "error_type": error_type,
         "request_id": run_id,

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/openai.py

@@ -24,6 +24,40 @@ def _as_mapping(call: Any) -> Any:
     return getattr(call, "__dict__", {})
 
 
+def _usage_int(usage: Any, group: str, field: str) -> int | None:
+    """One nested usage count, when the provider recorded it.
+
+    Absent and zero are different facts: a provider reporting 0 says the feature
+    was off for that call, where a missing count says nothing at all and must
+    not be read as zero.
+    """
+    detail = getattr(usage, group, None)
+    value = getattr(detail, field, None)
+    if value is None and isinstance(detail, dict):
+        value = detail.get(field)
+    if isinstance(value, bool) or not isinstance(value, int):
+        return None
+    return value
+
+
+def _usage_detail(usage: Any) -> dict[str, int]:
+    """Counts that sit beside the totals and are billed at their own rates.
+
+    `prompt_tokens` already includes the cached tokens, so a row without the
+    cache count bills them at the full input rate rather than the far cheaper
+    cache rate. Reasoning tokens are already inside `completion_tokens` and are
+    carried as detail only, never added to the total.
+    """
+    detail = {}
+    cached = _usage_int(usage, "prompt_tokens_details", "cached_tokens")
+    if cached is not None:
+        detail["cache_read_tokens"] = cached
+    reasoning = _usage_int(usage, "completion_tokens_details", "reasoning_tokens")
+    if reasoning is not None:
+        detail["reasoning_tokens"] = reasoning
+    return detail
+
+
 def normalize_completion(
     completion: Any,
     messages: Iterable[Any],
@@ -66,6 +100,7 @@ def normalize_completion(
         "endpoint": "chat.completions",
         "input_tokens": getattr(usage, "prompt_tokens", None) if usage else None,
         "output_tokens": getattr(usage, "completion_tokens", None) if usage else None,
+        **_usage_detail(usage),
         "error": content_fetch_error is not None,
         "error_type": (
             type(content_fetch_error).__name__ if content_fetch_error else None

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/portkey.py

@@ -5,10 +5,12 @@ import math
 import re
 import sys
 from dataclasses import dataclass
+from decimal import Decimal
 from datetime import datetime, timedelta, timezone
 from typing import Any, Callable
 
 from .. import __version__
+from ..billing_evidence import reported_cost
 from ..capture_contract import capture_row, capture_text, capture_tool_calls
 
 
@@ -237,6 +239,198 @@ def _timestamp_from_epoch(numeric: float, raw: Any) -> datetime:
         ) from exc
 
 
+# Portkey passes the upstream provider's usage block through untouched, so one
+# export carries every vendor's spelling of the same counts. Each is resolved by
+# path and the first present one wins. Reasoning tokens are already inside
+# res_units, so they are detail only and never added to output_tokens.
+_CACHE_READ_PATHS = (
+    ("input_tokens_details", "cached_tokens"),
+    ("prompt_tokens_details", "cached_tokens"),
+    ("cache_read_input_tokens",),
+)
+_CACHE_WRITE_PATHS = (
+    ("cache_creation_input_tokens",),
+    ("input_tokens_details", "cache_write_tokens"),
+)
+# Some responses carry the TTL split in place of the aggregate, so summing the
+# split is the only way to see the total.
+_CACHE_WRITE_5M_PATH = ("cache_creation", "ephemeral_5m_input_tokens")
+_CACHE_WRITE_1H_PATH = ("cache_creation", "ephemeral_1h_input_tokens")
+_CACHE_WRITE_TTL_PATHS = (_CACHE_WRITE_5M_PATH, _CACHE_WRITE_1H_PATH)
+_REASONING_PATHS = (
+    ("output_tokens_details", "reasoning_tokens"),
+    ("completion_tokens_details", "reasoning_tokens"),
+)
+
+
+def _is_int(value: Any) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool)
+
+
+def _dig(source: Any, path: tuple[str, ...]) -> Any:
+    """Follow a key path through nested dicts, returning None off the path.
+
+    The usage block is provider-supplied and reaches us through an error path as
+    readily as a success one, so any level may be missing or not a dict.
+    """
+    current = source
+    for key in path:
+        if not isinstance(current, dict):
+            return None
+        current = current.get(key)
+    return current
+
+
+def _first_int(source: Any, paths: tuple[tuple[str, ...], ...]) -> int | None:
+    for path in paths:
+        value = _dig(source, path)
+        if _is_int(value):
+            return value
+    return None
+
+
+def _first_present(source: Any, paths: tuple[tuple[str, ...], ...]) -> Any:
+    for path in paths:
+        value = _dig(source, path)
+        if value is not None:
+            return value
+    return None
+
+
+def _sum_ints(source: Any, paths: tuple[tuple[str, ...], ...]) -> int | None:
+    values = [value for path in paths if _is_int(value := _dig(source, path))]
+    return sum(values) if values else None
+
+
+def _usage_detail(response: dict) -> dict[str, Any]:
+    """Usage detail from a Portkey row's response, present keys only.
+
+    Absent and zero price differently, so a detail nobody reported stays absent
+    rather than becoming a plausible-looking 0 that hides a capture regression.
+    """
+    usage = response.get("usage")
+    detail: dict[str, Any] = {}
+
+    cache_read = _first_int(usage, _CACHE_READ_PATHS)
+    if cache_read is not None:
+        detail["cache_read_tokens"] = cache_read
+
+    write_5m = _dig(usage, _CACHE_WRITE_5M_PATH)
+    if _is_int(write_5m):
+        detail["cache_write_5m_tokens"] = write_5m
+    write_1h = _dig(usage, _CACHE_WRITE_1H_PATH)
+    if _is_int(write_1h):
+        detail["cache_write_1h_tokens"] = write_1h
+
+    cache_write = _first_int(usage, _CACHE_WRITE_PATHS)
+    if cache_write is None:
+        # Only the TTL split was reported: sum it so a consumer that reads just
+        # cache_write_tokens still sees every written token.
+        cache_write = _sum_ints(usage, _CACHE_WRITE_TTL_PATHS)
+    if cache_write is not None:
+        detail["cache_write_tokens"] = cache_write
+
+    reasoning = _first_int(usage, _REASONING_PATHS)
+    if reasoning is not None:
+        detail["reasoning_tokens"] = reasoning
+
+    # Premium tier and region are request metadata, not counts, and they are
+    # what makes priority/batch and regional pricing answerable at all. The
+    # ingest writer keeps unrecognised keys in calls.meta, so they survive
+    # without a schema change.
+    service_tier = _first_present(
+        {"response": response, "usage": usage},
+        (("response", "service_tier"), ("usage", "service_tier")),
+    )
+    if service_tier is not None:
+        detail["service_tier"] = service_tier
+
+    inference_geo = _dig(usage, ("inference_geo",))
+    if inference_geo is not None:
+        detail["inference_geo"] = inference_geo
+
+    server_tool_use = _dig(usage, ("server_tool_use",))
+    if isinstance(server_tool_use, dict) and server_tool_use:
+        detail["server_tool_use"] = server_tool_use
+
+    grounding_queries = _grounding_queries(response)
+    if grounding_queries is not None:
+        detail["grounding_queries"] = grounding_queries
+
+    searches = _web_search_calls(response)
+    if searches is not None:
+        detail["web_search_calls"] = searches
+
+    return detail
+
+
+def _web_search_calls(response: dict) -> int | None:
+    """How many searches the model ran, for providers that bill per search.
+
+    The count is in the output the model produced, not in `usage`, and a single
+    call runs several. It is a whole charge of its own: on this traffic it is
+    priced per search at a rate the token rates cannot express.
+    """
+    output = response.get("output")
+    if not isinstance(output, list):
+        return None
+    return sum(
+        1
+        for item in output
+        if isinstance(item, dict) and item.get("type") == "web_search_call"
+    )
+
+
+def _cost_usd_from_cents(cents: Any) -> Decimal | None:
+    """A row's cost in dollars, or None when it does not state a usable one.
+
+    Portkey states the cost in cents. Dividing in decimal keeps the value exact:
+    it ends up in a numeric column, and binary rounding introduced here survives
+    the whole way.
+
+    A bool is an int in Python, and ``Decimal("True")`` raises an error the
+    export converter does not catch, so one such row would end the window rather
+    than convert without a cost. A non-finite value is not a cost either.
+    """
+    if isinstance(cents, bool) or not isinstance(cents, (int, float)):
+        return None
+    value = Decimal(str(cents))
+    return value / 100 if value.is_finite() else None
+
+
+def _endpoint(response: dict) -> str | None:
+    """Which provider API the call went to, as the billing evidence names it.
+
+    A gateway's reported cost is only interpretable alongside the endpoint that
+    produced it, because the same gateway prices its endpoints differently.
+    """
+    if response.get("object") == "response":
+        return "responses"
+    if isinstance(response.get("choices"), list):
+        return "chat.completions"
+    return None
+
+
+def _grounding_queries(response: dict) -> int | None:
+    """How many grounding queries a Gemini response ran.
+
+    Google bills grounding per query, not per prompt, and one prompt runs
+    several, so the count cannot be derived from the call count. It sits outside
+    `usage`, under each choice's groundingMetadata.
+    """
+    choices = response.get("choices")
+    if not isinstance(choices, list):
+        return None
+    total = 0
+    seen = False
+    for choice in choices:
+        queries = _dig(choice, ("groundingMetadata", "webSearchQueries"))
+        if isinstance(queries, list):
+            seen = True
+            total += len(queries)
+    return total if seen else None
+
+
 def normalize_portkey_row(
     row: dict, *, import_context: ImportContext | None = None
 ) -> dict:
@@ -274,8 +468,7 @@ def normalize_portkey_row(
         else "portkey/backfill"
     )
 
-    cost = row.get("cost")
-    cost_usd = cost / 100 if isinstance(cost, (int, float)) else None
+    cost_usd = _cost_usd_from_cents(row.get("cost"))
 
     result = {
         "ts": ts,
@@ -287,7 +480,15 @@ def normalize_portkey_row(
         "latency_ms": row.get("response_time"),
         "error": is_error,
         "error_type": error_type,
-        "cost_usd": cost_usd,
+        # Portkey's own figure, named so it can be recognised as a gateway's
+        # amount rather than a number of unknown origin. `cost_usd` stays for
+        # application versions that only read the legacy field.
+        "cost_usd": str(cost_usd) if cost_usd is not None else None,
+        # Stated whether or not a cost came with the row: it is where the call
+        # was served, not a property of the amount.
+        "gateway": "portkey",
+        **reported_cost(cost_usd, source="portkey.cost"),
+        "endpoint": _endpoint(response),
         "request_id": request_id,
         "span_id": request_id,
         "trace_id": trace_id,
@@ -301,6 +502,7 @@ def normalize_portkey_row(
         "sdk_version": __version__,
         "content_opted_in": True,
     }
+    result.update(_usage_detail(response))
     if import_context is not None:
         result["import_source"] = import_context.source
         result["import_source_scope"] = import_context.source_scope

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/portkey_export.py

@@ -195,7 +195,7 @@ class PortkeyExportClient:
         return PortkeyExport(export_id=returned_id, total=None, status=status)
 
     def cancel_export(self, export_id: str) -> None:
-        self._api_request("POST", self._export_path(export_id, "/cancel"), body={})
+        self._api_request("POST", self._export_path(export_id, "/cancel"), body=None)
 
     def download_to(
         self, export_id: str, dest_path: str, *, on_progress: Callable[[], None] | None = None

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2/src/metergraphrelay.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraphrelay
-Version: 0.7.1
+Version: 0.7.2
 Summary: Move LLM trace data between systems: pull from providers, push to metergraph.
 Author: Vasiliy Radostev
 License-Expression: MIT
@@ -551,6 +551,9 @@ records**, the run splits it **once** into **10 sub-windows with
 absorbs the boundary overlaps). This split is one-shot, never recursive:
 if any single sub-window *still* exceeds 50,000 records, the run fails
 with a clear error rather than splitting further.
+Before splitting, the run cancels the never-started hourly draft on a best effort
+basis. If Portkey refuses the cancel, the run warns and continues because an
+unstarted draft only counts rows and exports nothing.
 
 **Before running this against your own data:** as in manual mode,
 request and response content is uploaded to metergraph, with no opt-out.

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/src/metergraphrelay.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/metergraphrelay/__init__.py
+src/metergraphrelay/billing_evidence.py
 src/metergraphrelay/capture_contract.py
 src/metergraphrelay/cli.py
 src/metergraphrelay/config.py
@@ -28,6 +29,7 @@ src/metergraphrelay/providers/openai.py
 src/metergraphrelay/providers/phoenix.py
 src/metergraphrelay/providers/portkey.py
 src/metergraphrelay/providers/portkey_export.py
+tests/test_billing_evidence.py
 tests/test_capture_contract.py
 tests/test_cli.py
 tests/test_config.py

metergraphrelay-0.7.2/tests/test_billing_evidence.py

@@ -0,0 +1,39 @@
+"""Tests for how an importer states where a cost figure came from."""
+
+from decimal import Decimal
+
+import pytest
+
+from metergraphrelay.billing_evidence import reported_cost
+
+
+def test_an_amount_is_named_by_its_source():
+    assert reported_cost(0.0012, source="langfuse.observation.totalCost") == {
+        "reported_cost_usd": "0.0012",
+        "reported_cost_source": "langfuse.observation.totalCost",
+    }
+
+
+def test_the_amount_keeps_every_digit_it_was_given():
+    """A cost lands in a numeric column, so rounding introduced here survives
+    the whole way."""
+    assert reported_cost(
+        Decimal("19.394766285"), source="portkey.cost"
+    )["reported_cost_usd"] == "19.394766285"
+
+
+@pytest.mark.parametrize("amount", [None, True, False, "", "abc", object()])
+def test_a_source_is_never_named_without_an_amount_behind_it(amount):
+    """A named source with no amount would read as a cost of nothing rather than
+    as no cost reported."""
+    assert reported_cost(amount, source="x.cost") == {}
+
+
+@pytest.mark.parametrize("amount", [-1, "-0.01", float("inf"), float("nan")])
+def test_an_amount_that_cannot_be_a_cost_is_refused(amount):
+    assert reported_cost(amount, source="x.cost") == {}
+
+
+def test_zero_is_a_cost():
+    """Nothing billed is a fact; it is not a missing figure."""
+    assert reported_cost(0, source="x.cost")["reported_cost_usd"] == "0"

{metergraphrelay-0.7.1 → metergraphrelay-0.7.2}/tests/test_portkey_sync.py

@@ -413,6 +413,41 @@ def test_over_threshold_cancels_unstarted_hourly_draft_and_splits_into_ten():
     assert mg.completed == ["lease-1"]                 # completed only after all ten pushed
 
 
+def test_cancel_failure_on_unstarted_hourly_draft_does_not_abort_the_split(capsys):
+    full = (WINDOW_START, WINDOW_END)
+
+    class CancelFailure(FakePortkey):
+        def cancel_export(self, export_id):
+            self.cancelled.append(export_id)
+            raise PortkeyExportError(
+                "Portkey export request failed: HTTP 400 Bad Request"
+            )
+
+    pk = CancelFailure({}, totals={full: VOLUME_SPLIT_THRESHOLD + 1})
+    original_create = pk.create_export
+
+    def seeding_create(*, window_start, window_end):
+        pk._rows.setdefault((window_start, window_end), [_portkey_row(f"r-{window_start}")])
+        return original_create(window_start=window_start, window_end=window_end)
+
+    pk.create_export = seeding_create
+    mg = FakeMeterGraph(_acquired())
+
+    outcome = _run(mg, pk, [])
+
+    assert outcome.status == "completed"
+    assert outcome.exit_code == 0
+    assert pk.cancelled == ["exp-1"]
+    assert len(pk.created) == 1 + 10
+    assert pk.started == [f"exp-{i}" for i in range(2, 12)]
+    assert mg.completed == ["lease-1"]
+    assert mg.abandoned == []
+    stderr = capsys.readouterr().err
+    assert "Warning" in stderr
+    assert "exp-1" in stderr
+    assert "400" in stderr
+
+
 def test_boundary_total_exactly_at_threshold_does_not_split():
     # total == 50_000 is NOT over the threshold: the hourly draft is used as-is.
     full = (WINDOW_START, WINDOW_END)
@@ -445,6 +480,30 @@ def test_subwindow_still_over_threshold_is_rejected_without_recursion():
     assert str(VOLUME_SPLIT_THRESHOLD) in outcome.detail or "recursiv" in outcome.detail.lower()
 
 
+def test_failed_hourly_cancel_is_not_retried_during_later_cleanup():
+    full = (WINDOW_START, WINDOW_END)
+
+    class CancelFailure(FakePortkey):
+        def cancel_export(self, export_id):
+            self.cancelled.append(export_id)
+            if export_id == "exp-1":
+                raise PortkeyExportError(
+                    "Portkey export request failed: HTTP 400 Bad Request"
+                )
+
+    pk = CancelFailure({}, totals={full: VOLUME_SPLIT_THRESHOLD + 1},
+                       default_total=VOLUME_SPLIT_THRESHOLD + 1)
+    mg = FakeMeterGraph(_acquired())
+
+    outcome = _run(mg, pk, [])
+
+    assert outcome.status == "failed"
+    assert outcome.exit_code == 1
+    assert mg.completed == []
+    assert mg.abandoned == ["lease-1"]
+    assert pk.cancelled.count("exp-1") == 1
+
+
 def test_planning_valueerror_from_bad_window_bounds_is_handled_failure():
     # The server hands out reversed window bounds and an oversized draft, so the
     # split planner calls split_window with end <= start and it raises ValueError.

metergraphrelay-0.7.1/src/metergraphrelay/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.7.1"