revenium-python-sdk 0.1.6__tar.gz → 0.1.7__tar.gz

{revenium_python_sdk-0.1.6/revenium_python_sdk.egg-info → revenium_python_sdk-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: revenium-python-sdk
-Version: 0.1.6
+Version: 0.1.7
 Summary: The official Revenium Python SDK — unified AI metering middleware for OpenAI, Anthropic, Google, Ollama, LiteLLM, Perplexity, and fal.ai.
 Author-email: Revenium <support@revenium.io>
 License: MIT
@@ -227,6 +227,98 @@ See [`examples/agentic_outcomes/`](examples/agentic_outcomes/) for runnable demo
 
 ---
 
+## Idempotency
+
+Every metering POST from the provider middleware automatically includes an `Idempotency-Key` header. If the Revenium API receives the same key with the same body within 24 hours, it returns the cached response instead of double-billing — making metering submissions safe to retry.
+
+### Default
+
+A fresh UUID v4 is generated automatically for every metering call. No action required.
+
+### Override
+
+Use the `idempotency_key` context manager to tie metering to a business-level identifier so the same logical operation never double-meters across retries:
+
+```python
+from revenium_middleware import idempotency_key
+
+with idempotency_key(f"order-{order_id}"):
+    response = openai.chat.completions.create(...)
+```
+
+The context manager is backed by `contextvars`, so it scopes correctly across threads and asyncio tasks.
+
+### Backend behavior
+
+| Scenario | Backend response |
+| -- | -- |
+| First call with key K and body B | Executes, caches for 24h |
+| Retry with same K and same B | Returns cached response (no double-bill) |
+| Same K with different B | `409 idempotency_key_mismatch` |
+| Concurrent in-flight with same K | `409 idempotency_key_in_progress` + `Retry-After: 1` |
+| Malformed key | `400 invalid_idempotency_key` |
+
+See [docs.revenium.io/integrations/idempotency](https://docs.revenium.io/integrations/idempotency) for full backend semantics.
+
+### Key format
+
+`Idempotency-Key` must be 1–255 printable ASCII characters. UUID v4 is the recommended format and what the SDK generates by default.
+
+---
+
+## Webhook Signature Verification
+
+Revenium signs every outbound webhook with HMAC-SHA256 when a signing secret is configured. The SDK ships a verification helper so your handler can validate signatures without writing crypto.
+
+Two headers arrive on every signed delivery:
+
+| Header | Value |
+| -- | -- |
+| `X-Revenium-Signature-256` | `sha256=<hex>`. During a 24h rotation overlap: `sha256=A, sha256=B`. |
+| `X-Revenium-Webhook-Timestamp` | Unix seconds at signing time. |
+
+### FastAPI example
+
+```python
+import os
+
+from fastapi import FastAPI, Header, HTTPException, Request
+
+from revenium_middleware.webhooks import verify_signature
+
+app = FastAPI()
+SIGNING_SECRETS = [os.environ["REVENIUM_WEBHOOK_SECRET"]]
+
+
+@app.post("/webhooks/revenium")
+async def receive(
+    request: Request,
+    x_revenium_signature_256: str = Header(...),
+    x_revenium_webhook_timestamp: str = Header(...),
+):
+    body = await request.body()
+    if not verify_signature(
+        payload=body,
+        signature_header=x_revenium_signature_256,
+        timestamp_header=x_revenium_webhook_timestamp,
+        secrets=SIGNING_SECRETS,
+    ):
+        raise HTTPException(status_code=401, detail="Invalid signature")
+
+    # ... process the event
+    return {"ok": True}
+```
+
+### Secret rotation
+
+When you rotate a signing secret in the Revenium dashboard with the default 24-hour overlap, both the old and new secrets are active simultaneously and every webhook is signed with both. Supply both values in `SIGNING_SECRETS` during the overlap window; remove the old one once it expires.
+
+### Webhooks without a signing secret
+
+Webhook deliveries without a configured signing secret arrive without HMAC headers. If your endpoint receives both signed and unsigned traffic, branch on header presence: treat missing headers as legacy unsigned mode and missing-signature-on-signed-only endpoints as an authentication failure.
+
+---
+
 ## Provider Usage Guides
 
 ### OpenAI

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/README.md

@@ -139,6 +139,98 @@ See [`examples/agentic_outcomes/`](examples/agentic_outcomes/) for runnable demo
 
 ---
 
+## Idempotency
+
+Every metering POST from the provider middleware automatically includes an `Idempotency-Key` header. If the Revenium API receives the same key with the same body within 24 hours, it returns the cached response instead of double-billing — making metering submissions safe to retry.
+
+### Default
+
+A fresh UUID v4 is generated automatically for every metering call. No action required.
+
+### Override
+
+Use the `idempotency_key` context manager to tie metering to a business-level identifier so the same logical operation never double-meters across retries:
+
+```python
+from revenium_middleware import idempotency_key
+
+with idempotency_key(f"order-{order_id}"):
+    response = openai.chat.completions.create(...)
+```
+
+The context manager is backed by `contextvars`, so it scopes correctly across threads and asyncio tasks.
+
+### Backend behavior
+
+| Scenario | Backend response |
+| -- | -- |
+| First call with key K and body B | Executes, caches for 24h |
+| Retry with same K and same B | Returns cached response (no double-bill) |
+| Same K with different B | `409 idempotency_key_mismatch` |
+| Concurrent in-flight with same K | `409 idempotency_key_in_progress` + `Retry-After: 1` |
+| Malformed key | `400 invalid_idempotency_key` |
+
+See [docs.revenium.io/integrations/idempotency](https://docs.revenium.io/integrations/idempotency) for full backend semantics.
+
+### Key format
+
+`Idempotency-Key` must be 1–255 printable ASCII characters. UUID v4 is the recommended format and what the SDK generates by default.
+
+---
+
+## Webhook Signature Verification
+
+Revenium signs every outbound webhook with HMAC-SHA256 when a signing secret is configured. The SDK ships a verification helper so your handler can validate signatures without writing crypto.
+
+Two headers arrive on every signed delivery:
+
+| Header | Value |
+| -- | -- |
+| `X-Revenium-Signature-256` | `sha256=<hex>`. During a 24h rotation overlap: `sha256=A, sha256=B`. |
+| `X-Revenium-Webhook-Timestamp` | Unix seconds at signing time. |
+
+### FastAPI example
+
+```python
+import os
+
+from fastapi import FastAPI, Header, HTTPException, Request
+
+from revenium_middleware.webhooks import verify_signature
+
+app = FastAPI()
+SIGNING_SECRETS = [os.environ["REVENIUM_WEBHOOK_SECRET"]]
+
+
+@app.post("/webhooks/revenium")
+async def receive(
+    request: Request,
+    x_revenium_signature_256: str = Header(...),
+    x_revenium_webhook_timestamp: str = Header(...),
+):
+    body = await request.body()
+    if not verify_signature(
+        payload=body,
+        signature_header=x_revenium_signature_256,
+        timestamp_header=x_revenium_webhook_timestamp,
+        secrets=SIGNING_SECRETS,
+    ):
+        raise HTTPException(status_code=401, detail="Invalid signature")
+
+    # ... process the event
+    return {"ok": True}
+```
+
+### Secret rotation
+
+When you rotate a signing secret in the Revenium dashboard with the default 24-hour overlap, both the old and new secrets are active simultaneously and every webhook is signed with both. Supply both values in `SIGNING_SECRETS` during the overlap window; remove the old one once it expires.
+
+### Webhooks without a signing secret
+
+Webhook deliveries without a configured signing secret arrive without HMAC headers. If your endpoint receives both signed and unsigned traffic, branch on header presence: treat missing headers as legacy unsigned mode and missing-signature-on-signed-only endpoints as an authentication failure.
+
+---
+
 ## Provider Usage Guides
 
 ### OpenAI

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "revenium-python-sdk"
-version = "0.1.6"
+version = "0.1.7"
 description = "The official Revenium Python SDK — unified AI metering middleware for OpenAI, Anthropic, Google, Ollama, LiteLLM, Perplexity, and fal.ai."
 readme = "README.md"
 requires-python = ">=3.8"

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/__init__.py

@@ -151,6 +151,9 @@ from ._core import (  # noqa: E402
     set_injected_metadata,
     clear_injected_metadata,
     merge_metadata,
+    idempotency_key,
+    get_idempotency_key,
+    set_idempotency_key,
     is_selective_metering_enabled,
 )
 
@@ -178,6 +181,9 @@ __all__ = [
     "set_injected_metadata",
     "clear_injected_metadata",
     "merge_metadata",
+    "idempotency_key",
+    "get_idempotency_key",
+    "set_idempotency_key",
     # Config exports
     "is_selective_metering_enabled",
     # Tool metering exports (from revenium_metering)

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/_core/__init__.py

@@ -6,6 +6,7 @@ provider-specific middleware implementations.
 """
 
 from .metering import run_async_in_thread, shutdown_event, client
+from .metering_submission import submit_ai_event
 from .exceptions import BudgetExceededError
 from .enforcement import check_enforcement, is_circuit_breaker_enabled, stop_polling
 from .context import (
@@ -17,6 +18,9 @@ from .context import (
     set_injected_metadata,
     clear_injected_metadata,
     merge_metadata,
+    idempotency_key,
+    get_idempotency_key,
+    set_idempotency_key,
 )
 from .decorators import revenium_meter, revenium_metadata, track_usage
 from .config import is_selective_metering_enabled
@@ -48,6 +52,7 @@ __all__ = [
     "client",
     "run_async_in_thread",
     "shutdown_event",
+    "submit_ai_event",
     # Enforcement / circuit breaker
     "BudgetExceededError",
     "check_enforcement",
@@ -66,6 +71,9 @@ __all__ = [
     "set_injected_metadata",
     "clear_injected_metadata",
     "merge_metadata",
+    "idempotency_key",
+    "get_idempotency_key",
+    "set_idempotency_key",
     # Config
     "is_selective_metering_enabled",
     # Field extraction

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/_core/context.py

@@ -6,8 +6,9 @@ whether code is currently executing inside a decorated function that should be m
 and to store metadata that should be injected into API calls.
 """
 
+import contextlib
 import contextvars
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Iterator
 
 # Context variable to track if we're inside a decorated function
 _decorated_function_context: contextvars.ContextVar[bool] = contextvars.ContextVar(
@@ -24,6 +25,11 @@ _injected_metadata_context: contextvars.ContextVar[Optional[Dict[str, Any]]] = c
     'revenium_injected_metadata', default=None
 )
 
+# Context variable to store an Idempotency-Key override for the current scope
+_idempotency_key_context: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    'revenium_idempotency_key', default=None
+)
+
 
 def is_inside_decorated_function() -> bool:
     """
@@ -107,3 +113,62 @@ def merge_metadata(api_metadata: Optional[Dict[str, Any]] = None) -> Dict[str, A
     merged = {**injected, **api}
     return merged
 
+
+def get_idempotency_key() -> Optional[str]:
+    """Return the Idempotency-Key override set on the current context, or None."""
+    return _idempotency_key_context.get()
+
+
+def set_idempotency_key(key: Optional[str]) -> contextvars.Token:
+    """Set the Idempotency-Key override on the current context. Returns a Token for reset().
+
+    Note: passing ``None`` is indistinguishable from "no override set" to consumers — both
+    cause the wrapper to fall through to UUID v4 generation. Use this function with a real
+    string for explicit overrides; rely on the ``idempotency_key()`` context manager for
+    scoped overrides that auto-reset on exit.
+
+    Raises:
+        ValueError: if ``key`` is the empty string. Mirrors the guard on the
+            ``idempotency_key()`` CM so empty strings can never reach the wrapper
+            via any entry point.
+    """
+    if key == "":
+        raise ValueError(
+            "idempotency_key must be a non-empty string; "
+            "the backend rejects empty keys"
+        )
+    return _idempotency_key_context.set(key)
+
+
+@contextlib.contextmanager
+def idempotency_key(key: str) -> Iterator[None]:
+    """Override the auto-generated Idempotency-Key for AI metering calls within the block.
+
+    Args:
+        key: The explicit key to use. Must be a non-empty string. Forwarded
+            verbatim to the backend, which enforces the 1-255 printable ASCII
+            constraint.
+
+    Raises:
+        ValueError: if ``key`` is the empty string. The backend would reject
+            empty keys with ``400 invalid_idempotency_key``, which the
+            provider middleware then swallows — failing fast at the CM
+            surfaces the bug at its source instead.
+
+    Example:
+        from revenium_middleware import idempotency_key
+
+        with idempotency_key(f"order-{order_id}"):
+            response = openai.chat.completions.create(...)
+    """
+    if key == "":
+        raise ValueError(
+            "idempotency_key must be a non-empty string; "
+            "the backend rejects empty keys and the SDK's middleware swallows the error"
+        )
+    token = _idempotency_key_context.set(key)
+    try:
+        yield
+    finally:
+        _idempotency_key_context.reset(token)
+

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/_core/fields.py

@@ -1,9 +1,17 @@
 import logging
+import threading
 import warnings
 from typing import Any, Dict, Mapping, Optional, Set, Tuple
 
 logger = logging.getLogger(__name__)
 
+# Dedup set for deprecated-alias logger.warning so high-volume callers don't get a flood
+# per call. Python's warnings module already dedupes warnings.warn by call site, but
+# logger.warning has no built-in dedup. The lock makes the check-then-add atomic so
+# concurrent threads can't both observe "not seen" and emit duplicate startup warnings.
+_WARNED_DEPRECATED_FIELDS: Set[Tuple[str, str]] = set()
+_WARNED_DEPRECATED_LOCK = threading.Lock()
+
 AGENTIC_JOB_FIELD_MAP = {
     "agenticJobId": ("agentic_job_id", "agenticJobId"),
     "agenticJobName": ("agentic_job_name", "agenticJobName"),
@@ -11,21 +19,6 @@ AGENTIC_JOB_FIELD_MAP = {
     "agenticJobVersion": ("agentic_job_version", "agenticJobVersion"),
 }
 
-# Tracks (old_field, new_field) pairs already warned about in this process,
-# so high-volume callers don't get a deprecation log flood per call.
-_WARNED_DEPRECATED_FIELDS: Set[Tuple[str, str]] = set()
-
-
-def _reset_deprecation_warning_cache() -> None:
-    """Clear the once-per-key deprecation-warning gate.
-
-    Intended for test isolation — production callers should not need this.
-    Test suites with autouse fixtures call this before each test so that tests
-    which assert a warning fires on a specific call do not bleed across each
-    other.
-    """
-    _WARNED_DEPRECATED_FIELDS.clear()
-
 
 def extract_field_with_fallback(
     source: Mapping[str, Any],
@@ -45,17 +38,20 @@ def extract_field_with_fallback(
 
     if source.get(old_snake) or source.get(old_camel):
         if not (source.get(new_snake) or source.get(new_camel)):
-            key = (old_camel, new_camel)
-            if key not in _WARNED_DEPRECATED_FIELDS:
-                _WARNED_DEPRECATED_FIELDS.add(key)
-                msg = (
-                    "Fields '%s' and '%s' are deprecated and are no longer "
-                    "accepted by the Revenium backend. The SDK is translating to "
-                    "'%s' for this call. Use '%s' or '%s' instead. The "
-                    "input-layer aliases will be removed in the next major release."
-                )
+            msg = (
+                "Fields '%s' and '%s' are deprecated and are no longer "
+                "accepted by the Revenium backend. The SDK is translating to "
+                "'%s' for this call. Use '%s' or '%s' instead. The "
+                "input-layer aliases will be removed in the next major release."
+            )
+            pair = (old_snake, new_snake)
+            with _WARNED_DEPRECATED_LOCK:
+                should_log = pair not in _WARNED_DEPRECATED_FIELDS
+                if should_log:
+                    _WARNED_DEPRECATED_FIELDS.add(pair)
+            if should_log:
                 logger.warning(msg, old_camel, old_snake, new_camel, new_camel, new_snake)
-                warnings.warn(msg % (old_camel, old_snake, new_camel, new_camel, new_snake), DeprecationWarning, stacklevel=3)
+            warnings.warn(msg % (old_camel, old_snake, new_camel, new_camel, new_snake), DeprecationWarning, stacklevel=3)
 
     return value
 

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/_core/metering.py

@@ -3,6 +3,7 @@ import time
 import logging
 import asyncio
 import threading
+import contextvars
 import atexit
 import signal
 from typing import Literal, Awaitable, Any, Optional, Callable
@@ -116,11 +117,12 @@ else:
 
 
 class MeteringThread(threading.Thread):
-    def __init__(self, coro, *args, **kwargs):
+    def __init__(self, coro, *args, ctx: Optional[contextvars.Context] = None, **kwargs):
         # Default to non-daemon threads so atexit handlers wait for them
         daemon = kwargs.pop('daemon', False)
         super().__init__(*args, **kwargs)
         self.coro = coro
+        self.ctx = ctx
         self.daemon = daemon # Store daemon status
         self.error = None
         self.loop = None
@@ -144,8 +146,11 @@ class MeteringThread(threading.Thread):
             asyncio.set_event_loop(self.loop)
             logger.debug(f"Metering thread {self.name} started with loop {id(self.loop)}")
             try:
-                # Run the coroutine until it completes
-                self.loop.run_until_complete(self.coro)
+                # Run the coroutine until it completes, inside the captured context if available
+                if self.ctx is not None:
+                    self.ctx.run(self.loop.run_until_complete, self.coro)
+                else:
+                    self.loop.run_until_complete(self.coro)
             finally:
                 # Ensure async generators are properly shut down
                 logger.debug(f"Shutting down async generators for loop {id(self.loop)} in thread {self.name}")
@@ -210,9 +215,13 @@ def run_async_in_thread(coroutine_or_func):
          return None
 
 
+    # Capture the current context so contextvars (e.g. idempotency_key) propagate
+    # into the worker thread, which otherwise starts with an empty context.
+    ctx = contextvars.copy_context()
+
     # Create and start the thread
     # Pass daemon=False explicitly if that's the desired default
-    thread = MeteringThread(coro, daemon=False)
+    thread = MeteringThread(coro, ctx=ctx, daemon=False)
     with _threads_lock:
         active_threads.append(thread)
     logger.debug(f"Starting and adding thread {thread.name} to active list.")

revenium_python_sdk-0.1.7/revenium_middleware/_core/metering_submission.py

@@ -0,0 +1,68 @@
+"""Centralized submission of AI metering events with Idempotency-Key injection."""
+from __future__ import annotations
+
+import uuid
+from typing import Any, Dict, Optional
+
+from revenium_middleware._core.context import get_idempotency_key
+from revenium_middleware._core.metering import client
+
+
+_AI_OPERATIONS = frozenset({"completion", "image", "video", "audio"})
+
+
+def submit_ai_event(
+    operation: str,
+    args: Dict[str, Any],
+    idempotency_key: Optional[str] = None,
+) -> Any:
+    """Submit an AI metering event with an Idempotency-Key header.
+
+    Args:
+        operation: One of "completion", "image", "video", "audio".
+        args: Keyword arguments forwarded to client.ai.create_<operation>.
+        idempotency_key: Optional explicit override. If None, the function
+            checks the current contextvar (set via the idempotency_key()
+            context manager or set_idempotency_key());
+            if that is also None, a UUID v4 is generated.
+
+    Returns:
+        Whatever client.ai.create_<operation> returns. Returns None when
+        the metering client is not configured (no API key).
+
+    Raises:
+        ValueError: if operation is not one of the recognized AI operations.
+    """
+    if client is None:
+        return None
+
+    if operation not in _AI_OPERATIONS:
+        raise ValueError(
+            f"Unknown AI metering operation {operation!r}; "
+            f"expected one of {sorted(_AI_OPERATIONS)}"
+        )
+
+    if idempotency_key is not None:
+        if idempotency_key == "":
+            raise ValueError(
+                "idempotency_key must be a non-empty string; "
+                "the backend rejects empty keys"
+            )
+        key = idempotency_key
+    else:
+        ctx_key = get_idempotency_key()
+        key = ctx_key if ctx_key is not None else str(uuid.uuid4())
+
+    existing_headers = args.get("extra_headers") or {}
+    if any(k.lower() == "idempotency-key" for k in existing_headers):
+        raise ValueError(
+            "Pass Idempotency-Key via the idempotency_key parameter, "
+            "not via extra_headers; the wrapper owns this header"
+        )
+    merged_args = {
+        **args,
+        "extra_headers": {**existing_headers, "Idempotency-Key": key},
+    }
+
+    method = getattr(client.ai, f"create_{operation}")
+    return method(**merged_args)

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/agentic_outcomes.py

@@ -16,6 +16,7 @@ import logging
 import threading
 import time
 import urllib.parse
+import uuid
 from dataclasses import dataclass
 from typing import Any, Dict, Optional
 
@@ -175,6 +176,8 @@ class AgenticOutcomeClient:
             prompts_truncated=payload.get("promptsTruncated"),
             error_reason=payload.get("errorReason"),
             extra_body=extra_body or None,
+            # Per-instance client; idempotency key generated inline (see FRONT-1208 spec exception).
+            extra_headers={"Idempotency-Key": str(uuid.uuid4())},
         )
         return payload
 

{revenium_python_sdk-0.1.6 → revenium_python_sdk-0.1.7}/revenium_middleware/anthropic/bedrock_adapter.py

@@ -653,6 +653,7 @@ class BedrockStreamWrapper:
         try:
             # Import here to avoid circular imports
             from revenium_middleware import shutdown_event
+            from revenium_middleware._core import submit_ai_event
             from .provider import Provider, get_provider_metadata
             from .middleware import _get_thread_safe_client, _safe_run_async_in_thread
             from .trace_fields import detect_vision_content
@@ -705,41 +706,41 @@ class BedrockStreamWrapper:
                     organization_name, product_name = extract_org_and_product(self.usage_metadata)
                     meta = extract_common_metadata(self.usage_metadata)
 
-                    result = client.ai.create_completion(
-                        cache_creation_token_count=0,
-                        cache_read_token_count=0,
-                        input_token_cost=None,
-                        output_token_cost=None,
-                        total_cost=None,
-                        output_token_count=completion_tokens,
-                        cost_type="AI",
-                        model=self.final_message.model,
-                        input_token_count=prompt_tokens,
-                        provider=provider_metadata["provider"],
-                        model_source=provider_metadata["model_source"],
-                        reasoning_token_count=0,
-                        request_time=self.request_time,
-                        response_time=self.response_time,
-                        completion_start_time=self.response_time,
-                        request_duration=int(request_duration),
-                        time_to_first_token=int(
+                    result = submit_ai_event("completion", {
+                        "cache_creation_token_count": 0,
+                        "cache_read_token_count": 0,
+                        "input_token_cost": None,
+                        "output_token_cost": None,
+                        "total_cost": None,
+                        "output_token_count": completion_tokens,
+                        "cost_type": "AI",
+                        "model": self.final_message.model,
+                        "input_token_count": prompt_tokens,
+                        "provider": provider_metadata["provider"],
+                        "model_source": provider_metadata["model_source"],
+                        "reasoning_token_count": 0,
+                        "request_time": self.request_time,
+                        "response_time": self.response_time,
+                        "completion_start_time": self.response_time,
+                        "request_duration": int(request_duration),
+                        "time_to_first_token": int(
                             self.first_token_time - self.request_start_time) if self.first_token_time else 0,
-                        stop_reason="END",
-                        total_token_count=prompt_tokens + completion_tokens,
-                        transaction_id=self.response_id,
-                        trace_id=meta["trace_id"],
-                        task_type=meta["task_type"],
-                        subscriber=subscriber if subscriber else None,
-                        organization_name=organization_name,
-                        subscription_id=meta["subscription_id"],
-                        product_name=product_name,
-                        agent=meta["agent"],
-                        is_streamed=True,
-                        operation_type="CHAT",
-                        response_quality_score=meta["response_quality_score"],
-                        middleware_source="PYTHON",
-                        extra_body=extra_body if extra_body else None,
-                    )
+                        "stop_reason": "END",
+                        "total_token_count": prompt_tokens + completion_tokens,
+                        "transaction_id": self.response_id,
+                        "trace_id": meta["trace_id"],
+                        "task_type": meta["task_type"],
+                        "subscriber": subscriber if subscriber else None,
+                        "organization_name": organization_name,
+                        "subscription_id": meta["subscription_id"],
+                        "product_name": product_name,
+                        "agent": meta["agent"],
+                        "is_streamed": True,
+                        "operation_type": "CHAT",
+                        "response_quality_score": meta["response_quality_score"],
+                        "middleware_source": "PYTHON",
+                        "extra_body": extra_body if extra_body else None,
+                    })
                     logger.debug("Metering call result for Bedrock stream: %s", result)
                 except Exception as e:
                     if not shutdown_event.is_set():