paid-python 0.3.6__py3-none-any.whl → 0.4.1__py3-none-any.whl

{paid/_vendor/opentelemetry → opentelemetry}/instrumentation/openai/v1/responses_wrappers.py

@@ -3,10 +3,58 @@ import pydantic
 import re
 import threading
 import time
+from typing import Any, Optional, Union
 
 from openai import AsyncStream, Stream
+from openai._legacy_response import LegacyAPIResponse
+from opentelemetry import context as context_api
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+    openai_attributes as OpenAIAttributes,
+)
+from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
+from opentelemetry.semconv_ai import SpanAttributes
+from opentelemetry.trace import SpanKind, Span, StatusCode, Tracer
+from typing_extensions import NotRequired
 from wrapt import ObjectProxy
 
+from opentelemetry.instrumentation.openai.shared import (
+    _extract_model_name_from_provider_format,
+    _set_request_attributes,
+    _set_span_attribute,
+    model_as_dict,
+)
+from opentelemetry.instrumentation.openai.utils import (
+    _with_tracer_wrapper,
+    dont_throw,
+    should_send_prompts,
+)
+
+
+def _get_openai_sentinel_types() -> tuple:
+    """Dynamically discover OpenAI sentinel types available in this SDK version.
+
+    OpenAI SDK uses sentinel objects (NOT_GIVEN, Omit) for unset optional parameters.
+    These types may not exist in older SDK versions, so we discover them at runtime.
+    """
+    sentinel_types = []
+    try:
+        from openai import NotGiven
+        sentinel_types.append(NotGiven)
+    except ImportError:
+        pass
+    try:
+        from openai import Omit
+        sentinel_types.append(Omit)
+    except ImportError:
+        pass
+    return tuple(sentinel_types)
+
+
+# Tuple of OpenAI sentinel types for isinstance() checks (empty if none available)
+_OPENAI_SENTINEL_TYPES: tuple = _get_openai_sentinel_types()
+
 # Conditional imports for backward compatibility
 try:
     from openai.types.responses import (
@@ -24,7 +72,7 @@ try:
     RESPONSES_AVAILABLE = True
 except ImportError:
     # Fallback types for older OpenAI SDK versions
-    from typing import Any, Dict, List, Union
+    from typing import Dict, List
 
     # Create basic fallback types
     FunctionToolParam = Dict[str, Any]
@@ -37,31 +85,25 @@ except ImportError:
     ResponseOutputMessageParam = Dict[str, Any]
     RESPONSES_AVAILABLE = False
 
-from openai._legacy_response import LegacyAPIResponse
-from opentelemetry import context as context_api
-from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
-from opentelemetry.semconv._incubating.attributes import (
-    gen_ai_attributes as GenAIAttributes,
-    openai_attributes as OpenAIAttributes,
-)
-from opentelemetry.semconv_ai import SpanAttributes
-from opentelemetry.semconv.attributes.error_attributes import ERROR_TYPE
-from opentelemetry.trace import SpanKind, Span, StatusCode, Tracer
-from typing import Any, Optional, Union, Literal
-from typing_extensions import NotRequired
+SPAN_NAME = "openai.response"
 
-from paid._vendor.opentelemetry.instrumentation.openai.shared import (
-    _set_span_attribute,
-    model_as_dict,
-)
 
-from paid._vendor.opentelemetry.instrumentation.openai.utils import (
-    _with_tracer_wrapper,
-    dont_throw,
-    should_send_prompts,
-)
+def _sanitize_sentinel_values(kwargs: dict) -> dict:
+    """Remove OpenAI sentinel values (NOT_GIVEN, Omit) from kwargs.
 
-SPAN_NAME = "openai.response"
+    OpenAI SDK uses sentinel objects for unset optional parameters.
+    These don't have dict methods like .get(), causing errors when
+    code chains calls like kwargs.get("reasoning", {}).get("summary").
+
+    This removes sentinel values so the default (e.g., {}) is used instead
+    when calling .get() on the sanitized dict.
+
+    If no sentinel types are available (older SDK), returns kwargs unchanged.
+    """
+    if not _OPENAI_SENTINEL_TYPES:
+        return kwargs
+    return {k: v for k, v in kwargs.items()
+            if not isinstance(v, _OPENAI_SENTINEL_TYPES)}
 
 
 def prepare_input_param(input_param: ResponseInputItemParam) -> ResponseInputItemParam:
@@ -134,8 +176,14 @@ class TracedData(pydantic.BaseModel):
     response_reasoning_effort: Optional[str] = pydantic.Field(default=None)
 
     # OpenAI service tier
-    request_service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] = pydantic.Field(default=None)
-    response_service_tier: Optional[Literal["auto", "default", "flex", "scale", "priority"]] = pydantic.Field(default=None)
+    request_service_tier: Optional[str] = pydantic.Field(default=None)
+    response_service_tier: Optional[str] = pydantic.Field(default=None)
+
+    # Trace context - to maintain trace continuity across async operations
+    trace_context: Any = pydantic.Field(default=None)
+
+    class Config:
+        arbitrary_types_allowed = True
 
 
 responses: dict[str, TracedData] = {}
@@ -189,12 +237,26 @@ def process_content_block(
 
 
 @dont_throw
+def prepare_kwargs_for_shared_attributes(kwargs):
+    """
+    Prepare kwargs for the shared _set_request_attributes function.
+    Maps responses API specific parameters to the common format.
+    """
+    prepared_kwargs = kwargs.copy()
+
+    # Map max_output_tokens to max_tokens for the shared function
+    if "max_output_tokens" in kwargs:
+        prepared_kwargs["max_tokens"] = kwargs["max_output_tokens"]
+
+    return prepared_kwargs
+
+
 def set_data_attributes(traced_response: TracedData, span: Span):
-    _set_span_attribute(span, GenAIAttributes.GEN_AI_SYSTEM, "openai")
-    _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, traced_response.request_model)
     _set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_ID, traced_response.response_id)
-    _set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, traced_response.response_model)
-    _set_span_attribute(span, OpenAIAttributes.OPENAI_REQUEST_SERVICE_TIER, traced_response.request_service_tier)
+
+    response_model = _extract_model_name_from_provider_format(traced_response.response_model)
+    _set_span_attribute(span, GenAIAttributes.GEN_AI_RESPONSE_MODEL, response_model)
+
     _set_span_attribute(span, OpenAIAttributes.OPENAI_RESPONSE_SERVICE_TIER, traced_response.response_service_tier)
     if usage := traced_response.usage:
         _set_span_attribute(span, GenAIAttributes.GEN_AI_USAGE_INPUT_TOKENS, usage.input_tokens)
@@ -437,24 +499,31 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
         return wrapped(*args, **kwargs)
     start_time = time.time_ns()
 
+    # Remove OpenAI sentinel values (NOT_GIVEN, Omit) to allow chained .get() calls
+    non_sentinel_kwargs = _sanitize_sentinel_values(kwargs)
+
     try:
         response = wrapped(*args, **kwargs)
         if isinstance(response, Stream):
+            # Capture current trace context to maintain trace continuity
+            ctx = context_api.get_current()
             span = tracer.start_span(
                 SPAN_NAME,
                 kind=SpanKind.CLIENT,
                 start_time=start_time,
+                context=ctx,
             )
+            _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
 
             return ResponseStream(
                 span=span,
                 response=response,
                 start_time=start_time,
-                request_kwargs=kwargs,
+                request_kwargs=non_sentinel_kwargs,
                 tracer=tracer,
             )
     except Exception as e:
-        response_id = kwargs.get("response_id")
+        response_id = non_sentinel_kwargs.get("response_id")
         existing_data = {}
         if response_id and response_id in responses:
             existing_data = responses[response_id].model_dump()
@@ -463,46 +532,53 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
                 start_time=existing_data.get("start_time", start_time),
                 response_id=response_id or "",
                 input=process_input(
-                    kwargs.get("input", existing_data.get("input", []))
+                    non_sentinel_kwargs.get("input", existing_data.get("input", []))
                 ),
-                instructions=kwargs.get(
+                instructions=non_sentinel_kwargs.get(
                     "instructions", existing_data.get("instructions")
                 ),
-                tools=get_tools_from_kwargs(kwargs) or existing_data.get("tools", []),
+                tools=get_tools_from_kwargs(non_sentinel_kwargs) or existing_data.get("tools", []),
                 output_blocks=existing_data.get("output_blocks", {}),
                 usage=existing_data.get("usage"),
-                output_text=kwargs.get(
+                output_text=non_sentinel_kwargs.get(
                     "output_text", existing_data.get("output_text", "")
                 ),
-                request_model=kwargs.get(
+                request_model=non_sentinel_kwargs.get(
                     "model", existing_data.get("request_model", "")
                 ),
                 response_model=existing_data.get("response_model", ""),
                 # Reasoning attributes
                 request_reasoning_summary=(
-                    kwargs.get("reasoning", {}).get(
+                    non_sentinel_kwargs.get("reasoning", {}).get(
                         "summary", existing_data.get("request_reasoning_summary")
                     )
                 ),
                 request_reasoning_effort=(
-                    kwargs.get("reasoning", {}).get(
+                    non_sentinel_kwargs.get("reasoning", {}).get(
                         "effort", existing_data.get("request_reasoning_effort")
                     )
                 ),
-                response_reasoning_effort=kwargs.get("reasoning", {}).get("effort"),
-                request_service_tier=kwargs.get("service_tier"),
+                response_reasoning_effort=non_sentinel_kwargs.get("reasoning", {}).get("effort"),
+                request_service_tier=non_sentinel_kwargs.get("service_tier"),
                 response_service_tier=existing_data.get("response_service_tier"),
+                # Capture trace context to maintain continuity
+                trace_context=existing_data.get("trace_context", context_api.get_current()),
             )
         except Exception:
             traced_data = None
 
+        # Restore the original trace context to maintain trace continuity
+        ctx = (traced_data.trace_context if traced_data and traced_data.trace_context
+               else context_api.get_current())
         span = tracer.start_span(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=(
                 start_time if traced_data is None else int(traced_data.start_time)
             ),
+            context=ctx,
         )
+        _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
         span.set_attribute(ERROR_TYPE, e.__class__.__name__)
         span.record_exception(e)
         span.set_status(StatusCode.ERROR, str(e))
@@ -518,7 +594,7 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
     else:
         existing_data = existing_data.model_dump()
 
-    request_tools = get_tools_from_kwargs(kwargs)
+    request_tools = get_tools_from_kwargs(non_sentinel_kwargs)
 
     merged_tools = existing_data.get("tools", []) + request_tools
 
@@ -534,40 +610,46 @@ def responses_get_or_create_wrapper(tracer: Tracer, wrapped, instance, args, kwa
         traced_data = TracedData(
             start_time=existing_data.get("start_time", start_time),
             response_id=parsed_response.id,
-            input=process_input(existing_data.get("input", kwargs.get("input"))),
-            instructions=existing_data.get("instructions", kwargs.get("instructions")),
+            input=process_input(existing_data.get("input", non_sentinel_kwargs.get("input"))),
+            instructions=existing_data.get("instructions", non_sentinel_kwargs.get("instructions")),
             tools=merged_tools if merged_tools else None,
             output_blocks={block.id: block for block in parsed_response.output}
             | existing_data.get("output_blocks", {}),
             usage=existing_data.get("usage", parsed_response.usage),
             output_text=existing_data.get("output_text", parsed_response_output_text),
-            request_model=existing_data.get("request_model", kwargs.get("model")),
+            request_model=existing_data.get("request_model", non_sentinel_kwargs.get("model")),
             response_model=existing_data.get("response_model", parsed_response.model),
             # Reasoning attributes
             request_reasoning_summary=(
-                kwargs.get("reasoning", {}).get(
+                non_sentinel_kwargs.get("reasoning", {}).get(
                     "summary", existing_data.get("request_reasoning_summary")
                 )
             ),
             request_reasoning_effort=(
-                kwargs.get("reasoning", {}).get(
+                non_sentinel_kwargs.get("reasoning", {}).get(
                     "effort", existing_data.get("request_reasoning_effort")
                 )
             ),
-            response_reasoning_effort=kwargs.get("reasoning", {}).get("effort"),
-            request_service_tier=existing_data.get("request_service_tier", kwargs.get("service_tier")),
+            response_reasoning_effort=non_sentinel_kwargs.get("reasoning", {}).get("effort"),
+            request_service_tier=existing_data.get("request_service_tier", non_sentinel_kwargs.get("service_tier")),
             response_service_tier=existing_data.get("response_service_tier", parsed_response.service_tier),
+            # Capture trace context to maintain continuity across async operations
+            trace_context=existing_data.get("trace_context", context_api.get_current()),
         )
         responses[parsed_response.id] = traced_data
     except Exception:
         return response
 
     if parsed_response.status == "completed":
+        # Restore the original trace context to maintain trace continuity
+        ctx = traced_data.trace_context if traced_data.trace_context else context_api.get_current()
         span = tracer.start_span(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=int(traced_data.start_time),
+            context=ctx,
         )
+        _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
         set_data_attributes(traced_data, span)
         span.end()
 
@@ -583,24 +665,31 @@ async def async_responses_get_or_create_wrapper(
         return await wrapped(*args, **kwargs)
     start_time = time.time_ns()
 
+    # Remove OpenAI sentinel values (NOT_GIVEN, Omit) to allow chained .get() calls
+    non_sentinel_kwargs = _sanitize_sentinel_values(kwargs)
+
     try:
         response = await wrapped(*args, **kwargs)
         if isinstance(response, (Stream, AsyncStream)):
+            # Capture current trace context to maintain trace continuity
+            ctx = context_api.get_current()
             span = tracer.start_span(
                 SPAN_NAME,
                 kind=SpanKind.CLIENT,
                 start_time=start_time,
+                context=ctx,
             )
+            _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
 
             return ResponseStream(
                 span=span,
                 response=response,
                 start_time=start_time,
-                request_kwargs=kwargs,
+                request_kwargs=non_sentinel_kwargs,
                 tracer=tracer,
             )
     except Exception as e:
-        response_id = kwargs.get("response_id")
+        response_id = non_sentinel_kwargs.get("response_id")
         existing_data = {}
         if response_id and response_id in responses:
             existing_data = responses[response_id].model_dump()
@@ -609,42 +698,49 @@ async def async_responses_get_or_create_wrapper(
                 start_time=existing_data.get("start_time", start_time),
                 response_id=response_id or "",
                 input=process_input(
-                    kwargs.get("input", existing_data.get("input", []))
+                    non_sentinel_kwargs.get("input", existing_data.get("input", []))
                 ),
-                instructions=kwargs.get(
+                instructions=non_sentinel_kwargs.get(
                     "instructions", existing_data.get("instructions", "")
                 ),
-                tools=get_tools_from_kwargs(kwargs) or existing_data.get("tools", []),
+                tools=get_tools_from_kwargs(non_sentinel_kwargs) or existing_data.get("tools", []),
                 output_blocks=existing_data.get("output_blocks", {}),
                 usage=existing_data.get("usage"),
-                output_text=kwargs.get("output_text", existing_data.get("output_text")),
-                request_model=kwargs.get("model", existing_data.get("request_model")),
+                output_text=non_sentinel_kwargs.get("output_text", existing_data.get("output_text")),
+                request_model=non_sentinel_kwargs.get("model", existing_data.get("request_model")),
                 response_model=existing_data.get("response_model"),
                 # Reasoning attributes
                 request_reasoning_summary=(
-                    kwargs.get("reasoning", {}).get(
+                    non_sentinel_kwargs.get("reasoning", {}).get(
                         "summary", existing_data.get("request_reasoning_summary")
                     )
                 ),
                 request_reasoning_effort=(
-                    kwargs.get("reasoning", {}).get(
+                    non_sentinel_kwargs.get("reasoning", {}).get(
                         "effort", existing_data.get("request_reasoning_effort")
                     )
                 ),
-                response_reasoning_effort=kwargs.get("reasoning", {}).get("effort"),
-                request_service_tier=kwargs.get("service_tier"),
+                response_reasoning_effort=non_sentinel_kwargs.get("reasoning", {}).get("effort"),
+                request_service_tier=non_sentinel_kwargs.get("service_tier"),
                 response_service_tier=existing_data.get("response_service_tier"),
+                # Capture trace context to maintain continuity
+                trace_context=existing_data.get("trace_context", context_api.get_current()),
             )
         except Exception:
             traced_data = None
 
+        # Restore the original trace context to maintain trace continuity
+        ctx = (traced_data.trace_context if traced_data and traced_data.trace_context
+               else context_api.get_current())
         span = tracer.start_span(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=(
                 start_time if traced_data is None else int(traced_data.start_time)
             ),
+            context=ctx,
         )
+        _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
         span.set_attribute(ERROR_TYPE, e.__class__.__name__)
         span.record_exception(e)
         span.set_status(StatusCode.ERROR, str(e))
@@ -660,7 +756,7 @@ async def async_responses_get_or_create_wrapper(
     else:
         existing_data = existing_data.model_dump()
 
-    request_tools = get_tools_from_kwargs(kwargs)
+    request_tools = get_tools_from_kwargs(non_sentinel_kwargs)
 
     merged_tools = existing_data.get("tools", []) + request_tools
 
@@ -677,40 +773,46 @@ async def async_responses_get_or_create_wrapper(
         traced_data = TracedData(
             start_time=existing_data.get("start_time", start_time),
             response_id=parsed_response.id,
-            input=process_input(existing_data.get("input", kwargs.get("input"))),
-            instructions=existing_data.get("instructions", kwargs.get("instructions")),
+            input=process_input(existing_data.get("input", non_sentinel_kwargs.get("input"))),
+            instructions=existing_data.get("instructions", non_sentinel_kwargs.get("instructions")),
             tools=merged_tools if merged_tools else None,
             output_blocks={block.id: block for block in parsed_response.output}
             | existing_data.get("output_blocks", {}),
             usage=existing_data.get("usage", parsed_response.usage),
             output_text=existing_data.get("output_text", parsed_response_output_text),
-            request_model=existing_data.get("request_model", kwargs.get("model")),
+            request_model=existing_data.get("request_model", non_sentinel_kwargs.get("model")),
             response_model=existing_data.get("response_model", parsed_response.model),
             # Reasoning attributes
             request_reasoning_summary=(
-                kwargs.get("reasoning", {}).get(
+                non_sentinel_kwargs.get("reasoning", {}).get(
                     "summary", existing_data.get("request_reasoning_summary")
                 )
             ),
             request_reasoning_effort=(
-                kwargs.get("reasoning", {}).get(
+                non_sentinel_kwargs.get("reasoning", {}).get(
                     "effort", existing_data.get("request_reasoning_effort")
                 )
             ),
-            response_reasoning_effort=kwargs.get("reasoning", {}).get("effort"),
-            request_service_tier=existing_data.get("request_service_tier", kwargs.get("service_tier")),
+            response_reasoning_effort=non_sentinel_kwargs.get("reasoning", {}).get("effort"),
+            request_service_tier=existing_data.get("request_service_tier", non_sentinel_kwargs.get("service_tier")),
             response_service_tier=existing_data.get("response_service_tier", parsed_response.service_tier),
+            # Capture trace context to maintain continuity across async operations
+            trace_context=existing_data.get("trace_context", context_api.get_current()),
         )
         responses[parsed_response.id] = traced_data
     except Exception:
         return response
 
     if parsed_response.status == "completed":
+        # Restore the original trace context to maintain trace continuity
+        ctx = traced_data.trace_context if traced_data.trace_context else context_api.get_current()
         span = tracer.start_span(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=int(traced_data.start_time),
+            context=ctx,
         )
+        _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
         set_data_attributes(traced_data, span)
         span.end()
 
@@ -723,18 +825,24 @@ def responses_cancel_wrapper(tracer: Tracer, wrapped, instance, args, kwargs):
     if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
         return wrapped(*args, **kwargs)
 
+    non_sentinel_kwargs = _sanitize_sentinel_values(kwargs)
+
     response = wrapped(*args, **kwargs)
     if isinstance(response, Stream):
         return response
     parsed_response = parse_response(response)
     existing_data = responses.pop(parsed_response.id, None)
     if existing_data is not None:
+        # Restore the original trace context to maintain trace continuity
+        ctx = existing_data.trace_context if existing_data.trace_context else context_api.get_current()
         span = tracer.start_span(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=existing_data.start_time,
             record_exception=True,
+            context=ctx,
         )
+        _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
         span.record_exception(Exception("Response cancelled"))
         set_data_attributes(existing_data, span)
         span.end()
@@ -749,18 +857,24 @@ async def async_responses_cancel_wrapper(
     if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
         return await wrapped(*args, **kwargs)
 
+    non_sentinel_kwargs = _sanitize_sentinel_values(kwargs)
+
     response = await wrapped(*args, **kwargs)
     if isinstance(response, (Stream, AsyncStream)):
         return response
     parsed_response = parse_response(response)
     existing_data = responses.pop(parsed_response.id, None)
     if existing_data is not None:
+        # Restore the original trace context to maintain trace continuity
+        ctx = existing_data.trace_context if existing_data.trace_context else context_api.get_current()
         span = tracer.start_span(
             SPAN_NAME,
             kind=SpanKind.CLIENT,
             start_time=existing_data.start_time,
             record_exception=True,
+            context=ctx,
         )
+        _set_request_attributes(span, prepare_kwargs_for_shared_attributes(non_sentinel_kwargs), instance)
         span.record_exception(Exception("Response cancelled"))
         set_data_attributes(existing_data, span)
         span.end()
@@ -788,7 +902,8 @@ class ResponseStream(ObjectProxy):
         super().__init__(response)
         self._span = span
         self._start_time = start_time
-        self._request_kwargs = request_kwargs or {}
+        # Filter sentinel values (defensive, in case called directly without prior filtering)
+        self._request_kwargs = _sanitize_sentinel_values(request_kwargs or {})
         self._tracer = tracer
         self._traced_data = traced_data or TracedData(
             start_time=start_time,
@@ -804,7 +919,9 @@ class ResponseStream(ObjectProxy):
             request_reasoning_summary=self._request_kwargs.get("reasoning", {}).get(
                 "summary"
             ),
-            request_reasoning_effort=self._request_kwargs.get("reasoning", {}).get("effort"),
+            request_reasoning_effort=self._request_kwargs.get("reasoning", {}).get(
+                "effort"
+            ),
             response_reasoning_effort=None,
             request_service_tier=self._request_kwargs.get("service_tier"),
             response_service_tier=None,

opentelemetry/instrumentation/openai/version.py

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

paid/client.py

@@ -1,8 +1,13 @@
 # This file was auto-generated by Fern from our API Definition.
+import os
 import typing
 import warnings
 
 import httpx
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
 from .agents.client import AgentsClient, AsyncAgentsClient
 from .contacts.client import AsyncContactsClient, ContactsClient
 from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
@@ -60,11 +65,19 @@ class Paid:
         *,
         base_url: typing.Optional[str] = None,
         environment: PaidEnvironment = PaidEnvironment.PRODUCTION,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.Client] = None,
     ):
+        # If token is not provided, try to get it from environment variable
+        if token is None:
+            token = os.environ.get("PAID_API_KEY")
+            if token is None:
+                raise ValueError(
+                    "API token must be provided either via the 'token' parameter or the 'PAID_API_KEY' environment variable"
+                )
+
         _defaulted_timeout = (
             timeout if timeout is not None else 60 if httpx_client is None else httpx_client.timeout.read
         )
@@ -338,11 +351,19 @@ class AsyncPaid:
         *,
         base_url: typing.Optional[str] = None,
         environment: PaidEnvironment = PaidEnvironment.PRODUCTION,
-        token: typing.Union[str, typing.Callable[[], str]],
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.AsyncClient] = None,
     ):
+        # If token is not provided, try to get it from environment variable
+        if token is None:
+            token = os.environ.get("PAID_API_KEY")
+            if token is None:
+                raise ValueError(
+                    "API token must be provided either via the 'token' parameter or the 'PAID_API_KEY' environment variable"
+                )
+
         _defaulted_timeout = (
             timeout if timeout is not None else 60 if httpx_client is None else httpx_client.timeout.read
         )

paid/tracing/__init__.py

@@ -7,13 +7,14 @@ from .distributed_tracing import (
     unset_tracing_token,
 )
 from .signal import signal
-from .tracing import initialize_tracing
+from .tracing import get_paid_tracer_provider, initialize_tracing
 
 __all__ = [
     "generate_tracing_token",
     "paid_autoinstrument",
     "paid_tracing",
     "initialize_tracing",
+    "get_paid_tracer_provider",
     "set_tracing_token",
     "unset_tracing_token",
     "signal",

paid/tracing/autoinstrumentation.py

@@ -22,8 +22,7 @@ except ImportError:
     ANTHROPIC_AVAILABLE = False
 
 try:
-    # from opentelemetry.instrumentation.openai import OpenAIInstrumentor
-    from paid._vendor.opentelemetry.instrumentation.openai import OpenAIInstrumentor  # remove once openai instrumentor is upstream
+    from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 
     OPENAI_AVAILABLE = True
 except ImportError:

paid/tracing/tracing.py

@@ -56,6 +56,22 @@ def set_token(token: str) -> None:
 # Initialized at module load with defaults, never None (uses no-op provider if not initialized or API key isn't available)
 paid_tracer_provider: Union[TracerProvider, NoOpTracerProvider] = NoOpTracerProvider()
 
+def get_paid_tracer_provider() -> Optional[TracerProvider]:
+    """Export the tracer provider to the user.
+    Initialize tracing if not already. Never return NoOpTracerProvider.
+
+    Returns:
+        The tracer provider instance.
+    """
+    global paid_tracer_provider
+
+    if get_token() is None:
+        initialize_tracing()
+
+    if not isinstance(paid_tracer_provider, TracerProvider):
+        return None
+
+    return paid_tracer_provider
 
 class PaidSpanProcessor(SpanProcessor):
     """