metergraphrelay 0.7.0__tar.gz → 0.7.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraphrelay
-Version: 0.7.0
+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.0 → 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.0 → metergraphrelay-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "metergraphrelay"
-version = "0.7.0"
+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.0 → metergraphrelay-0.7.2}/src/metergraphrelay/capture_contract.py

@@ -14,6 +14,9 @@ Two rules bind an importer:
   which the pipeline reads as native-search audit and passes over.
 * ``response_text`` is a string. A response carrying no text is ``""``; ``None``
   means the result itself is malformed.
+* A numeric the source never recorded is absent, not ``None``. The pipeline
+  validates ``latency_ms``, ``input_tokens`` and ``output_tokens`` whenever the
+  key is present, so an explicit ``None`` reads as a malformed number.
 
 Provider wire items that are neither a tool call nor search audit -- OpenAI
 ``reasoning`` items are the case seen in production -- have no representation in
@@ -30,6 +33,11 @@ from typing import Any
 # exempt from the tool-call shape. Passed through with their fields intact.
 NATIVE_SEARCH_AUDIT_TYPES = frozenset({"web_search_call", "web_fetch_call"})
 
+# Validated by the pipeline on presence, not on value: carrying one of these as
+# an explicit None says "this is the number" and fails, where leaving it out
+# says "the source did not record one" and is accepted.
+PRESENCE_CHECKED_NUMERIC_FIELDS = ("latency_ms", "input_tokens", "output_tokens")
+
 
 def capture_text(parts: list[str]) -> str:
     """Join a response's text parts into the contract's ``response_text``.
@@ -40,6 +48,21 @@ def capture_text(parts: list[str]) -> str:
     return "\n".join(parts)
 
 
+def capture_response_text(value: Any, *, content_opted_in: bool = True) -> str | None:
+    """A row's ``response_text``, as the contract requires it.
+
+    ``None`` is reserved for a row carrying no content at all, which the
+    pipeline recognises as the opt-out. On a row whose content *was* captured it
+    means something else entirely -- a malformed result -- and takes the row out
+    of every analysis. A reply with nothing to say is ``""``.
+    """
+    if not content_opted_in:
+        return None
+    if value is None:
+        return ""
+    return value if isinstance(value, str) else json.dumps(value)
+
+
 def _arguments(value: Any) -> str:
     """Render a tool call's arguments as the contract's JSON string."""
     if isinstance(value, str):
@@ -49,11 +72,18 @@ def _arguments(value: Any) -> str:
     return json.dumps(value)
 
 
-def capture_tool_call(item: Any) -> dict | None:
+def capture_tool_call(item: Any, *, position: int | None = None) -> dict | None:
     """Convert one provider tool item to the contract shape.
 
     Returns the item unchanged when it is native-search audit, and ``None`` for
     anything with no contract representation, which the caller drops.
+
+    ``position`` supplies a fallback identity for a recognised tool call whose
+    source recorded no id. Providers that log whatever an integration handed
+    them do occasionally omit it, and dropping the call would describe a tool
+    turn as though the model had replied with text alone. The contract needs the
+    id only to tell one call from another within a response, which the position
+    does. A call with no name is still dropped: there is nothing to identify.
     """
     if not isinstance(item, dict):
         return None
@@ -82,10 +112,12 @@ def capture_tool_call(item: Any) -> dict | None:
     else:
         return None
 
-    if not isinstance(call_id, str) or not call_id.strip():
-        return None
     if not isinstance(name, str) or not name.strip():
         return None
+    if not isinstance(call_id, str) or not call_id.strip():
+        if position is None:
+            return None
+        call_id = f"tool-{position}"
     return {"call_id": call_id, "name": name, "arguments": _arguments(arguments)}
 
 
@@ -94,6 +126,20 @@ def capture_tool_calls(items: Any) -> list | None:
     if not isinstance(items, (list, tuple)):
         return None
     converted = [
-        call for item in items if (call := capture_tool_call(item)) is not None
+        call
+        for position, item in enumerate(items)
+        if (call := capture_tool_call(item, position=position)) is not None
     ]
     return converted or None
+
+
+def capture_row(row: dict) -> dict:
+    """Drop the numerics a source never recorded, so the row stays readable.
+
+    Every other field is passed through untouched.
+    """
+    return {
+        key: value
+        for key, value in row.items()
+        if value is not None or key not in PRESENCE_CHECKED_NUMERIC_FIELDS
+    }

{metergraphrelay-0.7.0 → 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.0 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/braintrust.py

@@ -9,6 +9,8 @@ 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
 
@@ -279,14 +281,11 @@ def _content_blocks(blocks: list) -> tuple[str | None, list | None]:
             text_parts.append(block["text"])
         elif block.get("type") == "tool_use":
             tool_calls.append(block)
-    return ("\n".join(text_parts) or None), (tool_calls or None)
+    return ("\n".join(text_parts) or None), capture_tool_calls(tool_calls)
 
 
 def _message_output(message: dict[str, Any]) -> tuple[str | None, list | None]:
-    raw_tool_calls = message.get("tool_calls")
-    tool_calls = (
-        raw_tool_calls if isinstance(raw_tool_calls, list) and raw_tool_calls else None
-    )
+    tool_calls = capture_tool_calls(message.get("tool_calls"))
     content = message.get("content")
     if isinstance(content, str):
         return (content or None), tool_calls
@@ -515,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"],
@@ -523,7 +523,7 @@ def normalize_span(
         "content_opted_in": True,
         "request_json": request_json,
         "request_text": request_text,
-        "response_text": response_text,
+        "response_text": capture_response_text(response_text),
         "tool_calls": tool_calls,
         "tool_names": _tool_names(tool_calls),
         "trace_id": span.get("root_span_id"),
@@ -536,7 +536,7 @@ def normalize_span(
         row["import_source"] = import_context.source
         row["import_source_scope"] = import_context.source_scope
         row["import_event_id"] = canonical_import_event_id(span.get("id"))
-    return row
+    return capture_row(row)
 
 
 def _cleanup_temp_file(tmp_path: str) -> None:

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

@@ -11,6 +11,8 @@ 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
 
 DEFAULT_LANGFUSE_HOST = "https://cloud.langfuse.com"
@@ -296,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)
@@ -314,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
@@ -332,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,
@@ -342,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),
@@ -381,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"))
 
@@ -392,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"],
@@ -401,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"],
@@ -409,7 +450,7 @@ def normalize_observation(
         "content_opted_in": True,
         "request_json": request_json,
         "request_text": request_text,
-        "response_text": response_text,
+        "response_text": capture_response_text(response_text),
         "trace_id": observation["traceId"],
         "span_id": observation["id"],
         "parent_span_id": observation.get("parentObservationId"),
@@ -423,7 +464,7 @@ def normalize_observation(
         row["import_source"] = import_context.source
         row["import_source_scope"] = import_context.source_scope
         row["import_event_id"] = canonical_import_event_id(observation.get("id"))
-    return row
+    return capture_row(row)
 
 
 def _cleanup_temp_file(tmp_path: str) -> None:

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

@@ -39,6 +39,8 @@ 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
 
@@ -472,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,
@@ -480,7 +483,7 @@ def normalize_run(
         "content_opted_in": True,
         "request_json": request_json,
         "request_text": request_text,
-        "response_text": _response_text(run.get("outputs")),
+        "response_text": capture_response_text(_response_text(run.get("outputs"))),
         "trace_id": run.get("trace_id"),
         "span_id": run_id,
         "parent_span_id": run.get("parent_run_id"),
@@ -491,7 +494,7 @@ def normalize_run(
         row["import_source"] = import_context.source
         row["import_source_scope"] = import_context.source_scope
         row["import_event_id"] = canonical_import_event_id(run.get("id"))
-    return row
+    return capture_row(row)
 
 
 def _cleanup_temp_file(tmp_path: str) -> None:

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

@@ -7,6 +7,55 @@ from itertools import islice
 from typing import Any, Iterable
 
 from .. import __version__
+from ..capture_contract import capture_response_text, capture_row, capture_tool_calls
+
+
+def _as_mapping(call: Any) -> Any:
+    """An SDK tool-call object as a plain mapping, however the client models it."""
+    if isinstance(call, dict):
+        return call
+    for attribute in ("model_dump", "to_dict", "dict"):
+        dump = getattr(call, attribute, None)
+        if callable(dump):
+            try:
+                return dump()
+            except TypeError:
+                continue
+    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(
@@ -25,6 +74,7 @@ def normalize_completion(
     content_opted_in = include_content and content_fetch_error is None
     request_json: str | None = None
     response_text: str | None = None
+    tool_calls: list | None = None
     if content_opted_in:
         request_json = json.dumps(
             [{"role": m.role, "content": m.content} for m in message_list]
@@ -33,9 +83,16 @@ def normalize_completion(
         # the model's own reply — that lives on the completion object itself.
         choices = getattr(completion, "choices", None) or []
         if choices:
-            response_text = getattr(choices[0].message, "content", None)
+            message = choices[0].message
+            response_text = getattr(message, "content", None)
+            # A tool-only reply carries its answer in the tool call and no text.
+            # Recording the empty text without the call would describe the turn
+            # as an empty response rather than the tool use it was.
+            tool_calls = capture_tool_calls(
+                [_as_mapping(call) for call in getattr(message, "tool_calls", None) or []]
+            )
 
-    return {
+    return capture_row({
         "ts": ts,
         "provider": "openai",
         "model": completion.model,
@@ -43,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
@@ -52,10 +110,13 @@ def normalize_completion(
         "route": route,
         "content_opted_in": content_opted_in,
         "request_json": request_json,
-        "response_text": response_text,
+        "response_text": capture_response_text(
+            response_text, content_opted_in=content_opted_in
+        ),
+        "tool_calls": tool_calls,
         "sdk": "metergraphrelay",
         "sdk_version": __version__,
-    }
+    })
 
 
 def pull_openai(

{metergraphrelay-0.7.0 → metergraphrelay-0.7.2}/src/metergraphrelay/providers/phoenix.py

@@ -34,6 +34,7 @@ from datetime import datetime
 from typing import Any, Callable
 
 from .. import __version__
+from ..capture_contract import capture_response_text, capture_row
 from ..window import normalize_utc_designator
 from ..import_identity import ImportContext, canonical_import_event_id
 
@@ -383,7 +384,7 @@ def normalize_span(
         "content_opted_in": True,
         "request_json": request_json,
         "request_text": request_text,
-        "response_text": _response_text(attributes),
+        "response_text": capture_response_text(_response_text(attributes)),
         "tool_names": _tool_names(attributes),
         "trace_id": context.get("trace_id"),
         "span_id": span_id,
@@ -395,7 +396,7 @@ def normalize_span(
         row["import_source"] = import_context.source
         row["import_source_scope"] = import_context.source_scope
         row["import_event_id"] = canonical_import_event_id(span_id)
-    return row
+    return capture_row(row)
 
 
 def _cleanup_temp_file(tmp_path: str) -> None:

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

@@ -5,11 +5,13 @@ 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 ..capture_contract import capture_text, capture_tool_calls
+from ..billing_evidence import reported_cost
+from ..capture_contract import capture_row, capture_text, capture_tool_calls
 
 
 # Shared with the other sync providers; re-exported here for existing imports.
@@ -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,11 +502,12 @@ 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
         result["import_event_id"] = import_event_id  # validated, stripped id
-    return result
+    return capture_row(result)
 
 
 def convert_portkey_export(

{metergraphrelay-0.7.0 → 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.0 → metergraphrelay-0.7.2/src/metergraphrelay.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraphrelay
-Version: 0.7.0
+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.0 → 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.0 → metergraphrelay-0.7.2}/tests/test_capture_contract.py

@@ -15,6 +15,7 @@ import pytest
 
 from metergraphrelay.capture_contract import (
     NATIVE_SEARCH_AUDIT_TYPES,
+    capture_response_text,
     capture_text,
     capture_tool_call,
     capture_tool_calls,
@@ -126,3 +127,33 @@ def test_no_surviving_tool_calls_is_none_not_an_empty_list():
     assert capture_tool_calls([{"type": "reasoning", "id": "rs-1"}]) is None
     assert capture_tool_calls([]) is None
     assert capture_tool_calls(None) is None
+
+
+def test_a_recognised_tool_call_with_no_id_is_identified_by_position():
+    # Providers that log whatever an integration handed them sometimes omit the
+    # id. Dropping the call would describe a tool turn as text alone.
+    calls = capture_tool_calls(
+        [
+            {"type": "text", "text": "ignored"},
+            {"type": "tool_use", "name": "search", "input": {}},
+        ]
+    )
+
+    assert calls == [{"call_id": "tool-1", "name": "search", "arguments": "{}"}]
+
+
+def test_a_tool_call_with_no_name_is_dropped_even_with_a_position():
+    assert capture_tool_calls([{"type": "tool_use", "id": "t-1"}]) is None
+
+
+def test_capture_response_text_spells_a_text_less_reply_as_empty():
+    assert capture_response_text(None) == ""
+    assert capture_response_text("hi") == "hi"
+    assert capture_response_text({"a": 1}) == '{"a": 1}'
+
+
+def test_capture_response_text_leaves_an_opted_out_row_without_content():
+    # The pipeline reads None here as the content opt-out, which is the one
+    # place None is correct.
+    assert capture_response_text(None, content_opted_in=False) is None
+    assert capture_response_text("hi", content_opted_in=False) is None

{metergraphrelay-0.7.0 → 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.0/src/metergraphrelay/__init__.py

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