nullrunio
diff --git a/‎src/nullrun/instrumentation/auto.py‎
Lines changed: 55 additions & 1 deletion b/‎src/nullrun/instrumentation/auto.py‎
Lines changed: 55 additions & 1 deletion
diff --git a/‎src/nullrun/runtime.py‎
Lines changed: 14 additions & 1 deletion b/‎src/nullrun/runtime.py‎
Lines changed: 14 additions & 1 deletion
diff --git a/‎tests/test_batch_response_parsing.py‎
Lines changed: 235 additions & 0 deletions b/‎tests/test_batch_response_parsing.py‎
Lines changed: 235 additions & 0 deletions
@@ -476,6 +476,40 @@ def _bedrock_extractor(body: bytes, status: int) -> ExtractedUsage | None:
 }
 
 
+def _extract_model_from_request_body(request: httpx.Request) -> str | None:
+    """2026-06-28 (Issue 2 fix): fall back to the ``model`` field embedded
+    in the LLM request body when the response body extractor returned
+    ``None`` for ``model``.
+
+    The user typically passes ``ChatOpenAI(model="gpt-4.1-mini")`` and
+    that string appears in the request body's ``model`` field — even if
+    the response omits it (streaming edge cases, Responses API,
+    middleware that strips model from responses). Returning the
+    request-side model keeps the SDK's cost event attributable to the
+    real catalog entry (``gpt-4.1-mini`` substring → 400 microcents /
+    1M input in ``MODEL_RATES``) instead of falling through to
+    ``DEFAULT_RATE`` ($0 per call).
+
+    Returns ``None`` if the body is not JSON, has no ``model`` field,
+    or has an empty ``model``. Callers must treat the result as
+    optional and still surface the SDK's "missing model" warning when
+    both response and request lookups fail.
+    """
+    try:
+        body = request.content
+        if not body:
+            return None
+        payload = json.loads(body)
+    except (json.JSONDecodeError, ValueError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+    val = payload.get("model")
+    if isinstance(val, str) and val:
+        return val
+    return None
+
+
 def _match_extractor(host: str) -> Callable[[bytes, int], ExtractedUsage | None] | None:
     """Return the extractor for `host`, or None if the host is not a known
     LLM endpoint. We match exact host first, then any subdomain (e.g.
@@ -683,6 +717,26 @@ def _emit(
         # ``coverage_seen`` view in the dashboard would be empty for
         # the majority of customers.
         _safe_bump_coverage(self._runtime, "_coverage_seen", host)
+
+        # 2026-06-28 (Issue 2 fix): if the extractor returned ``None``
+        # for ``model`` (response body lacked the field — observed for
+        # some OpenAI Responses-API and Anthropic streaming edge cases),
+        # fall back to the model name embedded in the request body. The
+        # backend cost pipeline logs WARN and falls back to DEFAULT_RATE
+        # (≈$0 per call) whenever ``model`` is missing — see
+        # ``backend/src/cost/pipeline.rs:164`` ``unwrap_or("default")``
+        # and ``backend/src/cost/constants.rs::rate_for``. Without
+        # this fallback, every gpt-4.1-mini / claude-haiku-4 call where
+        # the response body omits ``model`` was being silently
+        # zero-billed. Request body is the next authoritative source:
+        # SDK users pass ``model="gpt-4.1-mini"`` in the ChatOpenAI
+        # constructor.
+        model_from_response = usage.get("model")
+        model_for_event = (
+            model_from_response
+            or _extract_model_from_request_body(request)
+        )
+
         try:
             # Phase 4.1: lift cache / reasoning / finish / tool names
             # out of raw_usage onto the event itself. The backend's
@@ -695,7 +749,7 @@ def _emit(
                     "type": "llm_call",
                     "provider": _provider_label(host),
                     "host": host,
-                    "model": usage.get("model"),
+                    "model": model_for_event,
                     "tokens": usage.get("total_tokens", 0),
                     "input_tokens": usage.get("prompt_tokens", 0),
                     "output_tokens": usage.get("completion_tokens", 0),
 
@@ -1556,6 +1556,19 @@ def track_coverage(self) -> dict[str, Any] | None:
 
         Background emission is driven by ``start_coverage_reporter``;
         most callers don't invoke this method directly.
+
+        Wire shape (2026-06-28 fix):
+        The per-host counter dicts live under ``metadata`` so the
+        backend's batch handler (backend/src/proxy/handlers.rs:5909
+        -5923) reads them from ``sdk_event.metadata``. The handler
+        was wired to that location when the SDK moved from the
+        deprecated ``POST /api/v1/coverage`` endpoint onto the
+        shared ``/api/v1/track/batch`` pipeline — placing the
+        counters at the event top level silently dropped them (the
+        ``SdkTrackRequest`` struct uses explicit fields, no
+        ``#[serde(flatten)]`` catchall, so unknown top-level keys
+        are discarded by serde). Nesting under ``metadata`` matches
+        what the handler reads.
         """
         stats = self.coverage_report()
         seen_total = sum(stats["seen"].values())
@@ -1564,7 +1577,7 @@ def track_coverage(self) -> dict[str, Any] | None:
             return None
         return self.track_event(
             "coverage_report",
-            **{
+            metadata={
                 "seen": stats["seen"],
                 "tracked": stats["tracked"],
                 "streaming_skipped": stats["streaming_skipped"],
 
@@ -0,0 +1,235 @@
+"""Contract tests for backend BatchTrackResponse parsing.
+
+Audit 2026-06-28: backend renamed `BatchTrackResponse.actions_taken`
+(Vec<String> of debug names) → `BatchTrackResponse.actions`
+(Vec<ActionTaken> structured) + `messages` (Vec<String> display-only).
+Single /track still uses `TrackResponse.actions_taken` (Vec<ActionTaken>)
+— separate endpoint, separate schema.
+
+These tests pin both schemas so a future backend rename can't silently
+break the SDK. Forward-compat path (legacy `actions_taken` dropped in
+SDK 0.8.0 per CHANGELOG §0.8.0) is documented but no longer parsed.
+"""
+
+from __future__ import annotations
+
+import pytest
+import respx
+from httpx import Response
+
+from nullrun.runtime import NullRunRuntime
+import nullrun.decorators as _dec
+import nullrun.actions as _act
+
+
+BASE_URL = "https://api.test.nullrun.io"
+
+
+@pytest.fixture
+def mock_api():
+    """Activate the global respx mock for the duration of the test and
+    pre-register /api/v1/auth/verify (the auth handshake that
+    NullRunRuntime.__init__ triggers). Each test pins its own
+    /api/v1/track/batch response via ``respx.post(...).mock(...)``.
+
+    Why ``with respx.mock:`` and not ``with respx.mock(...) as router:``:
+    parenthesised ``respx.mock(...)`` creates a *local* MockRouter, but
+    ``respx.post(...)`` is a module-level helper that always writes to
+    the *global* router. The two don't share state, so per-test
+    ``respx.post(...)`` mocks wouldn't be visible to the local router.
+    Bare ``respx.mock:`` re-uses the global router so module-level
+    ``respx.post(...)`` calls land on the active context — same pattern
+    used by ``tests/conftest.py``.
+    """
+    with respx.mock:
+        respx.post(f"{BASE_URL}/api/v1/auth/verify").mock(
+            return_value=Response(
+                200,
+                json={
+                    "organization_id": "ws-test",
+                    "workflow_id": "00000000-0000-0000-0000-000000000001",
+                    "plan": "pro",
+                    "features": [],
+                    "limits": {"max_cost_cents": 10000},
+                },
+            )
+        )
+        yield
+
+
+def _runtime(api_key: str = "test-key"):
+    """Build a runtime with the test API key and base URL.
+
+    Returns the constructed instance directly. ``NullRunRuntime.__init__``
+    does NOT assign ``_instance`` — only ``get_instance()`` does that —
+    so reading ``NullRunRuntime._instance`` after a direct constructor
+    call returns ``None``.
+    """
+    NullRunRuntime._instance = None
+    _dec._runtime = None
+    _act._action_handler = None
+    rt = NullRunRuntime(
+        api_key=api_key,
+        api_url=BASE_URL,
+        debug=True,
+        polling=False,
+    )
+    # Keep _instance in sync with conftest.py's `make_runtime` so the
+    # @protect decorator's lazy resolver finds this runtime too.
+    NullRunRuntime._instance = rt
+    _dec._runtime = rt
+    return rt
+
+
+# -----------------------------------------------------------------------------
+# New schema (post 2026-06-27 backend rename)
+# -----------------------------------------------------------------------------
+
+
+def test_new_schema_actions_and_messages_processed(mock_api):
+    """Backend 2026-06-27+ sends `actions` (structured) + `messages` (strings)."""
+    rt = _runtime()
+    route = respx.post(f"{BASE_URL}/api/v1/track/batch").mock(
+        return_value=Response(
+            200,
+            json={
+                "processed": 3,
+                "actions": [
+                    {"type": "rate_limit", "reason": "exceeded"},
+                    {"type": "budget_cap", "reason": "100 cents over"},
+                ],
+                "messages": [
+                    "1 event rejected: budget cap exceeded",
+                ],
+                "snapshots": [],
+                "accepted_event_ids": ["e1", "e2"],
+                "rejected_count": 0,
+                "rejection_details": [],
+            },
+        )
+    )
+
+    # Trigger a batch send (track_llm triggers batch flush internally)
+    # NOTE: the fixture already wraps the test in `respx.mock(...)`, so
+    # we must NOT add another `with mock_api:` here — re-entering the
+    # router clears the auth/verify mock registered by the fixture
+    # (respx's `__exit__` calls `rollback()` + `reset()`).
+    rt._transport._send_batch_with_retry_info(
+        batch=[
+            {
+                "event_type": "llm_call",
+                "workflow_id": "wf-1",
+                "model": "gpt-4",
+                "tokens": 100,
+                "cost_cents": 1,
+            }
+        ]
+    )
+
+    assert route.called
+
+
+def test_new_schema_messages_only_no_actions(mock_api):
+    """Display-only messages with empty actions should not raise."""
+    rt = _runtime()
+    respx.post(f"{BASE_URL}/api/v1/track/batch").mock(
+        return_value=Response(
+            200,
+            json={
+                "processed": 1,
+                "actions": [],
+                "messages": ["event accepted with warnings"],
+                "snapshots": [],
+                "accepted_event_ids": ["e1"],
+                "rejected_count": 0,
+                "rejection_details": [],
+            },
+        )
+    )
+
+    rt._transport._send_batch_with_retry_info(
+        batch=[
+            {
+                "event_type": "llm_call",
+                "workflow_id": "wf-1",
+                "model": "gpt-4",
+                "tokens": 100,
+                "cost_cents": 1,
+            }
+        ]
+    )
+    # No exception = pass
+
+
+def test_new_schema_empty_actions_no_messages(mock_api):
+    """All-accepted batch with empty actions/messages must not raise."""
+    rt = _runtime()
+    respx.post(f"{BASE_URL}/api/v1/track/batch").mock(
+        return_value=Response(
+            200,
+            json={
+                "processed": 1,
+                "actions": [],
+                "messages": [],
+                "snapshots": [],
+                "accepted_event_ids": ["e1"],
+                "rejected_count": 0,
+                "rejection_details": [],
+            },
+        )
+    )
+
+    rt._transport._send_batch_with_retry_info(
+        batch=[
+            {
+                "event_type": "llm_call",
+                "workflow_id": "wf-1",
+                "model": "gpt-4",
+                "tokens": 100,
+                "cost_cents": 1,
+            }
+        ]
+    )
+
+
+# -----------------------------------------------------------------------------
+# Backward-compat: legacy `actions_taken` (Vec<String>) is intentionally dropped
+# -----------------------------------------------------------------------------
+
+
+def test_legacy_actions_taken_string_field_does_not_crash(mock_api):
+    """Old backend (pre-2026-06-27) sent `actions_taken: Vec<String>` of
+    debug names. SDK 0.8.0 reads `actions` only. A legacy response must
+    not crash — missing `actions` is treated as empty."""
+    rt = _runtime()
+    respx.post(f"{BASE_URL}/api/v1/track/batch").mock(
+        return_value=Response(
+            200,
+            json={
+                "processed": 1,
+                # Legacy field — SDK should ignore it.
+                "actions_taken": ["rate_limit_exceeded"],
+                # New fields absent → empty defaults.
+                "snapshots": [],
+                "accepted_event_ids": ["e1"],
+                "rejected_count": 0,
+                "rejection_details": [],
+            },
+        )
+    )
+
+    # Should NOT raise. The legacy `actions_taken` field is ignored
+    # (per transport.py:1176-1177 comment, "legacy actions_taken
+    # fallback was removed"). `actions = data.get("actions") or []`
+    # returns [].
+    rt._transport._send_batch_with_retry_info(
+        batch=[
+            {
+                "event_type": "llm_call",
+                "workflow_id": "wf-1",
+                "model": "gpt-4",
+                "tokens": 100,
+                "cost_cents": 1,
+            }
+        ]
+    )