paid-python 1.0.4__tar.gz → 1.0.6__tar.gz

{paid_python-1.0.4 → paid_python-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paid-python
-Version: 1.0.4
+Version: 1.0.6
 Summary: 
 Requires-Python: >=3.10,<3.14
 Classifier: Intended Audience :: Developers

{paid_python-1.0.4 → paid_python-1.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ dynamic = ["version"]
 
 [tool.poetry]
 name = "paid-python"
-version = "1.0.4"
+version = "1.0.6"
 description = ""
 readme = "README.md"
 authors = []

{paid_python-1.0.4 → paid_python-1.0.6}/src/paid/core/client_wrapper.py

@@ -24,12 +24,12 @@ class BaseClientWrapper:
         import platform
 
         headers: typing.Dict[str, str] = {
-            "User-Agent": "paid-python/1.0.4",
+            "User-Agent": "paid-python/1.0.6",
             "X-Fern-Language": "Python",
             "X-Fern-Runtime": f"python/{platform.python_version()}",
             "X-Fern-Platform": f"{platform.system().lower()}/{platform.release()}",
             "X-Fern-SDK-Name": "paid-python",
-            "X-Fern-SDK-Version": "1.0.4",
+            "X-Fern-SDK-Version": "1.0.6",
             **(self.get_custom_headers() or {}),
         }
         headers["Authorization"] = f"Bearer {self._get_token()}"

{paid_python-1.0.4 → paid_python-1.0.6}/src/paid/tracing/anthropic_patches/patches.py

@@ -15,8 +15,13 @@ _original_async_messages_stream = None
 # Originals for the beta path, keyed by method name.
 _beta_originals: Dict[str, Any] = {}
 
+# Originals for response-ID patches.
+_response_id_originals: Dict[str, Any] = {}
+
 _BETA_MODULE = "anthropic.resources.beta.messages.messages"
 
+_ATTR_RESPONSE_ID = "gen_ai.response.id"
+
 
 def instrument_anthropic() -> None:
     """Apply all Anthropic patches. Call after AnthropicInstrumentor().instrument()."""
@@ -24,6 +29,8 @@ def instrument_anthropic() -> None:
     _patch_message_stream_manager()
     _wrap_async_messages_stream()
     _patch_response_accumulator_for_beta()
+    _patch_response_id_extraction()
+    _patch_streaming_response_id_extraction()
     _wrap_beta_messages()
 
 
@@ -38,6 +45,7 @@ def uninstrument_anthropic() -> None:
         _original_async_messages_stream = None
 
     _uninstrument_beta_messages()
+    _uninstrument_response_id_patches()
 
 def _patch_stream_context_managers() -> None:
     try:
@@ -120,14 +128,26 @@ class _AsyncMessageStreamManagerProxy(ObjectProxy):  # type: ignore[misc]
     def __init__(self, manager: Any, span: trace_api.Span) -> None:
         super().__init__(manager)
         self._self_span = span
+        self._self_stream: Any = None
 
     async def __aenter__(self):  # type: ignore[misc]
-        return await self.__wrapped__.__aenter__()
+        stream = await self.__wrapped__.__aenter__()
+        self._self_stream = stream
+        return stream
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):  # type: ignore[misc]
         try:
             return await self.__wrapped__.__aexit__(exc_type, exc_val, exc_tb)
         finally:
+            try:
+                # Try to capture response ID from the stream's final message snapshot
+                stream = self._self_stream
+                if stream is not None:
+                    final_msg = getattr(stream, "_MessageStream__final_message_snapshot", None)
+                    if final_msg is not None and hasattr(final_msg, "id") and final_msg.id:
+                        self._self_span.set_attribute(_ATTR_RESPONSE_ID, final_msg.id)
+            except Exception:
+                logger.debug("Failed to capture response ID from async stream", exc_info=True)
             try:
                 if exc_type:
                     self._self_span.set_status(trace_api.Status(trace_api.StatusCode.ERROR, str(exc_val)))
@@ -178,7 +198,7 @@ def _wrap_async_messages_stream() -> None:
 
 
 def _patch_response_accumulator_for_beta() -> None:
-    """Extend _MessageResponseAccumulator.process_chunk to handle beta event types."""
+    """Extend _MessageResponseAccumulator.process_chunk to handle beta event types and capture response IDs."""
     try:
         from openinference.instrumentation.anthropic._stream import _MessageResponseAccumulator
     except ImportError:
@@ -196,13 +216,21 @@ def _patch_response_accumulator_for_beta() -> None:
         logger.debug("Could not import beta event types, skipping beta accumulator patch")
         return
 
+    try:
+        from anthropic.types.raw_message_start_event import RawMessageStartEvent
+    except ImportError:
+        RawMessageStartEvent = None  # type: ignore[assignment,misc]
+
     _original_process_chunk = _MessageResponseAccumulator.process_chunk
 
     def _process_chunk_with_beta(self, chunk):  # type: ignore[misc]
-        """Handles both regular and beta event types."""
+        """Handles both regular and beta event types, and captures response IDs."""
         if isinstance(chunk, BetaRawMessageStartEvent):
             self._is_null = False
             self._current_message_idx += 1
+            # Capture response ID from beta message start
+            if hasattr(chunk.message, "id") and chunk.message.id:
+                self._values += {"response_id": chunk.message.id}
             value = {
                 "messages": {
                     "index": str(self._current_message_idx),
@@ -254,11 +282,84 @@ def _patch_response_accumulator_for_beta() -> None:
             }
             self._values += value
         else:
-            # Non-beta event — delegate to the original.
+            # Non-beta event — capture response ID from regular RawMessageStartEvent
+            # before delegating to the original handler.
+            if RawMessageStartEvent is not None and isinstance(chunk, RawMessageStartEvent):
+                if hasattr(chunk.message, "id") and chunk.message.id:
+                    self._values += {"response_id": chunk.message.id}
             return _original_process_chunk(self, chunk)
 
     _MessageResponseAccumulator.process_chunk = _process_chunk_with_beta  # type: ignore[method-assign]
-    logger.debug("Patched _MessageResponseAccumulator.process_chunk for beta event types")
+    logger.debug("Patched _MessageResponseAccumulator.process_chunk for beta event types and response IDs")
+
+
+def _patch_response_id_extraction() -> None:
+    """Patch openinference to extract response.id from non-streaming Anthropic messages."""
+    try:
+        from openinference.instrumentation.anthropic import _wrappers
+    except ImportError:
+        logger.debug("Could not import openinference anthropic _wrappers, skipping response ID patch")
+        return
+
+    _original = _wrappers._get_llm_model_name_from_response
+    _response_id_originals["_get_llm_model_name_from_response"] = _original
+
+    def _patched(message):  # type: ignore[misc]
+        yield from _original(message)
+        if response_id := getattr(message, "id", None):
+            yield _ATTR_RESPONSE_ID, response_id
+
+    _wrappers._get_llm_model_name_from_response = _patched  # type: ignore[attr-defined]
+    logger.debug("Patched _get_llm_model_name_from_response to also yield response ID")
+
+
+def _patch_streaming_response_id_extraction() -> None:
+    """Patch openinference _MessageResponseExtractor to yield response ID from accumulated data."""
+    try:
+        from openinference.instrumentation.anthropic._stream import _MessageResponseExtractor
+    except ImportError:
+        logger.debug("Could not import _MessageResponseExtractor, skipping streaming response ID patch")
+        return
+
+    _original_get_extra = _MessageResponseExtractor.get_extra_attributes
+    _response_id_originals["get_extra_attributes"] = _original_get_extra
+
+    def _get_extra_with_response_id(self):  # type: ignore[misc]
+        yield from _original_get_extra(self)
+        try:
+            result = self._response_accumulator._result()
+            if result and (response_id := result.get("response_id")):
+                yield _ATTR_RESPONSE_ID, response_id
+        except Exception:
+            pass
+
+    _MessageResponseExtractor.get_extra_attributes = _get_extra_with_response_id  # type: ignore[method-assign]
+    logger.debug("Patched _MessageResponseExtractor.get_extra_attributes for response IDs")
+
+
+def _uninstrument_response_id_patches() -> None:
+    """Restore original methods patched by _patch_response_id_extraction / _patch_streaming_response_id_extraction."""
+    if "_get_llm_model_name_from_response" in _response_id_originals:
+        try:
+            from openinference.instrumentation.anthropic import _wrappers
+
+            _wrappers._get_llm_model_name_from_response = _response_id_originals.pop(  # type: ignore[attr-defined]
+                "_get_llm_model_name_from_response"
+            )
+        except Exception:
+            pass
+
+    if "get_extra_attributes" in _response_id_originals:
+        try:
+            from openinference.instrumentation.anthropic._stream import _MessageResponseExtractor
+
+            _MessageResponseExtractor.get_extra_attributes = _response_id_originals.pop(  # type: ignore[method-assign]
+                "get_extra_attributes"
+            )
+        except Exception:
+            pass
+
+    _response_id_originals.clear()
 
 
 # ---------------------------------------------------------------------------

{paid_python-1.0.4 → paid_python-1.0.6}/src/paid/tracing/autoinstrumentation.py

@@ -249,14 +249,22 @@ def _instrument_langchain() -> None:
 def _instrument_google_genai() -> None:
     """
     Instrument Google GenAI using openinference-instrumentation-google-genai.
+
+    Applies patches on top of the base instrumentor to capture response IDs — see
+    ``paid.tracing.gemini_patches`` for full details.
     """
     if not GOOGLE_GENAI_AVAILABLE:
         logger.warning("Google GenAI instrumentation library not available, skipping instrumentation")
         return
 
+    from .gemini_patches import instrument_google_genai
+
     logger.debug("[paid:autoinstrument] Instrumenting google-genai with GoogleGenAIInstrumentor, provider=%s",
                  type(tracing.paid_tracer_provider).__name__)
     GoogleGenAIInstrumentor().instrument(tracer_provider=tracing.paid_tracer_provider)
+
+    instrument_google_genai()
+
     _initialized_instrumentors.append("google-genai")
     logger.info("Google GenAI auto-instrumentation enabled")
 

paid_python-1.0.6/src/paid/tracing/gemini_patches/__init__.py

@@ -0,0 +1,15 @@
+"""Patches for openinference-instrumentation-google-genai.
+
+Adds response ID extraction (gen_ai.response.id) to both non-streaming
+and streaming Google GenAI spans.
+"""
+
+from .patches import (
+    instrument_google_genai,
+    uninstrument_google_genai,
+)
+
+__all__ = [
+    "instrument_google_genai",
+    "uninstrument_google_genai",
+]

paid_python-1.0.6/src/paid/tracing/gemini_patches/patches.py

@@ -0,0 +1,101 @@
+"""Monkey-patches for openinference-instrumentation-google-genai.
+
+Adds response ID extraction to both non-streaming and streaming spans.
+"""
+
+from __future__ import annotations
+
+from paid.logger import logger
+
+_ATTR_RESPONSE_ID = "gen_ai.response.id"
+
+# Store originals for uninstrumentation
+_originals: dict = {}
+
+
+def instrument_google_genai() -> None:
+    """Apply all Google GenAI patches. Call after GoogleGenAIInstrumentor().instrument()."""
+    _patch_response_id_extraction()
+    _patch_streaming_response_id_extraction()
+
+
+def uninstrument_google_genai() -> None:
+    """Restore original Google GenAI methods."""
+    if "get_attributes_from_generate_content" in _originals:
+        try:
+            from openinference.instrumentation.google_genai import (
+                _response_attributes_extractor as mod,
+            )
+
+            mod._ResponseAttributesExtractor._get_attributes_from_generate_content = _originals.pop(  # type: ignore[method-assign]
+                "get_attributes_from_generate_content"
+            )
+        except Exception:
+            pass
+
+    if "stream_get_extra_attributes" in _originals:
+        try:
+            from openinference.instrumentation.google_genai import _stream as stream_mod
+
+            stream_mod._ResponseExtractor.get_extra_attributes = _originals.pop(  # type: ignore[method-assign]
+                "stream_get_extra_attributes"
+            )
+        except Exception:
+            pass
+
+    _originals.clear()
+
+
+def _patch_response_id_extraction() -> None:
+    """Patch openinference to extract response_id from non-streaming Gemini responses."""
+    try:
+        from openinference.instrumentation.google_genai import (
+            _response_attributes_extractor as mod,
+        )
+    except ImportError:
+        logger.debug(
+            "Could not import openinference google_genai _response_attributes_extractor, "
+            "skipping response ID patch"
+        )
+        return
+
+    _original = mod._ResponseAttributesExtractor._get_attributes_from_generate_content
+    _originals["get_attributes_from_generate_content"] = _original
+
+    def _patched(self, response, request_parameters):  # type: ignore[misc]
+        yield from _original(self, response=response, request_parameters=request_parameters)
+        if response_id := getattr(response, "response_id", None):
+            yield _ATTR_RESPONSE_ID, response_id
+
+    mod._ResponseAttributesExtractor._get_attributes_from_generate_content = _patched  # type: ignore[method-assign]
+    logger.debug(
+        "Patched _ResponseAttributesExtractor._get_attributes_from_generate_content "
+        "to also yield response ID"
+    )
+
+
+def _patch_streaming_response_id_extraction() -> None:
+    """Patch openinference _ResponseExtractor to yield response_id from accumulated streaming data."""
+    try:
+        from openinference.instrumentation.google_genai import _stream as stream_mod
+    except ImportError:
+        logger.debug(
+            "Could not import openinference google_genai _stream, "
+            "skipping streaming response ID patch"
+        )
+        return
+
+    _original_get_extra = stream_mod._ResponseExtractor.get_extra_attributes
+    _originals["stream_get_extra_attributes"] = _original_get_extra
+
+    def _get_extra_with_response_id(self):  # type: ignore[misc]
+        yield from _original_get_extra(self)
+        try:
+            result = self._response_accumulator._result()
+            if result and (response_id := result.get("response_id")):
+                yield _ATTR_RESPONSE_ID, response_id
+        except Exception:
+            pass
+
+    stream_mod._ResponseExtractor.get_extra_attributes = _get_extra_with_response_id  # type: ignore[method-assign]
+    logger.debug("Patched _ResponseExtractor.get_extra_attributes for response IDs")

{paid_python-1.0.4 → paid_python-1.0.6}/src/paid/tracing/tracing.py

@@ -19,6 +19,7 @@ from opentelemetry.trace import NonRecordingSpan, NoOpTracerProvider, SpanContex
 from opentelemetry.util.types import Attributes
 
 from paid.logger import logger
+from paid.version import __version__ as _paid_version
 
 DEFAULT_COLLECTOR_ENDPOINT = (
     os.environ.get("PAID_OTEL_COLLECTOR_ENDPOINT") or "https://collector.agentpaid.io:4318/v1/traces"
@@ -223,6 +224,9 @@ class PaidSpanProcessor(SpanProcessor):
         if agent_id:
             span.set_attribute("external_agent_id", agent_id)
 
+        # Always stamp the SDK version so the backend can identify the source
+        span.set_attribute("paid.sdk.version", f"python-{_paid_version}")
+
         logger.debug(
             "[paid:span] on_start: name=%s, customer_id=%s, agent_id=%s",
             span.name, customer_id, agent_id,
@@ -445,13 +449,11 @@ def initialize_tracing(
 
         set_token(api_key)
 
-        resource = Resource(attributes={"api.key": api_key})
         # Create isolated tracer provider for Paid - don't use or modify global provider
         # Pass explicit sampler and span_limits to avoid inheriting from OTEL env vars
         # (OTEL_TRACES_SAMPLER=always_off or OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT=1
         #  set by the client app would silently break this)
         paid_tracer_provider = TracerProvider(
-            resource=resource,
             sampler=ALWAYS_ON,
             span_limits=SpanLimits(
                 max_span_attributes=128,
@@ -482,7 +484,7 @@ def initialize_tracing(
         # client OTEL env vars (e.g. OTEL_EXPORTER_OTLP_HEADERS, OTEL_EXPORTER_OTLP_TIMEOUT)
         otlp_exporter = OTLPSpanExporter(
             endpoint=collector_endpoint,
-            headers={"_paid": "1"},  # Non-empty to prevent env var OTEL_EXPORTER_OTLP_HEADERS leak (empty dict is falsy)
+            headers={"Authorization": f"Bearer {api_key}"},
             timeout=10,  # Explicit timeout to prevent env var OTEL_EXPORTER_OTLP_TIMEOUT override
         )
 

paid_python-1.0.6/src/paid/version.py

@@ -0,0 +1,6 @@
+from importlib import metadata
+
+try:
+    __version__ = metadata.version("paid-python")
+except metadata.PackageNotFoundError:
+    __version__ = "unknown"

paid_python-1.0.4/src/paid/version.py

@@ -1,3 +0,0 @@
-from importlib import metadata
-
-__version__ = metadata.version("paid-python")