tracecast 0.2.6__tar.gz → 0.2.8__tar.gz

{tracecast-0.2.6 → tracecast-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracecast
-Version: 0.2.6
+Version: 0.2.8
 Summary: LLM observability SDK — framework-agnostic tracing for AI applications
 Author: Pedro Castanheira Costa
 License: MIT

{tracecast-0.2.6 → tracecast-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tracecast"
-version = "0.2.6"
+version = "0.2.8"
 description = "LLM observability SDK — framework-agnostic tracing for AI applications"
 readme = "README.md"
 license = { text = "MIT" }

{tracecast-0.2.6 → tracecast-0.2.8}/tests/test_cost_calculator.py

@@ -1,5 +1,5 @@
 import pytest
-from tracecast.core.cost_calculator import calculate_cost, PRICE_TABLE
+from tracecast.core.cost_calculator import calculate_cost, calculate_audio_cost, PRICE_TABLE
 
 @pytest.mark.parametrize("model", [
     "gpt-4o", "gpt-4o-mini", "gpt-4-turbo",
@@ -151,3 +151,53 @@ def test_modelos_sem_suporte_a_cache_nao_tem_chave_cached():
     modelos_sem_cache = ["gpt-4-turbo", "gemini-2.5-flash", "llama-4-scout"]
     for model in modelos_sem_cache:
         assert "cached" not in PRICE_TABLE[model], f"{model} nao deveria ter preco de cache"
+
+
+# --- gpt-4.1-nano (bug: ausente da tabela, custo virava $0 silenciosamente) ---
+
+def test_gpt_4_1_nano_tem_preco():
+    assert "gpt-4.1-nano" in PRICE_TABLE
+
+
+def test_calcula_custo_gpt_4_1_nano():
+    # $0.10 / $0.40 por 1M tokens = 0.00010 / 0.00040 por 1k
+    cost = calculate_cost("gpt-4.1-nano", tokens_in=1000, tokens_out=1000)
+    assert abs(cost - (0.00010 + 0.00040)) < 1e-9
+
+
+def test_gpt_4_1_nano_cached_e_25_pct_do_input():
+    # mesmo padrao dos irmaos gpt-4.1 / gpt-4.1-mini: cached = 25% do input
+    entry = PRICE_TABLE["gpt-4.1-nano"]
+    assert abs(entry["cached"] - entry["input"] * 0.25) < 1e-9
+
+
+# --- embeddings (bug: nunca precificados, custo $0 mesmo se instrumentados) ---
+
+@pytest.mark.parametrize("model,expected_input", [
+    ("text-embedding-3-small", 0.00002),
+    ("text-embedding-3-large", 0.00013),
+    ("text-embedding-ada-002", 0.00010),
+])
+def test_calcula_custo_embeddings(model, expected_input):
+    cost = calculate_cost(model, tokens_in=1000, tokens_out=0)
+    assert abs(cost - expected_input) < 1e-9
+
+
+# --- audio (bug: whisper/tts nunca precificados nem instrumentados) ---
+
+def test_calculate_audio_cost_whisper_por_minuto():
+    cost = calculate_audio_cost("whisper-1", minutes=2.5)
+    assert abs(cost - (2.5 * 0.006)) < 1e-9
+
+
+def test_calculate_audio_cost_tts_por_caractere():
+    cost = calculate_audio_cost("gpt-4o-mini-tts", chars=1000)
+    assert cost > 0
+
+
+def test_calculate_audio_cost_modelo_desconhecido_retorna_zero():
+    assert calculate_audio_cost("modelo-inexistente", minutes=10) == 0.0
+
+
+def test_calculate_audio_cost_sem_uso_retorna_zero():
+    assert calculate_audio_cost("whisper-1") == 0.0

{tracecast-0.2.6 → tracecast-0.2.8}/tracecast/__init__.py

@@ -8,7 +8,7 @@ from .decorators import trace_cast, trace_span, set_default_tracer
 from .core.scoring import score
 from .prompts import create_prompt, get_prompt, set_label, PromptVersion
 from .integrations.llm import trace_llm_call, wrap_openai, wrap_anthropic
-from .instrument import auto_instrument
+from .instrument import auto_instrument, instrument_openai
 from .exporters.dict_exporter import DictExporter
 
 __all__ = [
@@ -18,5 +18,5 @@ __all__ = [
     "trace_cast", "trace_span", "set_default_tracer", "score",
     "create_prompt", "get_prompt", "set_label", "PromptVersion",
     "trace_llm_call", "wrap_openai", "wrap_anthropic",
-    "auto_instrument", "DictExporter",
+    "auto_instrument", "instrument_openai", "DictExporter",
 ]

{tracecast-0.2.6 → tracecast-0.2.8}/tracecast/core/cost_calculator.py

@@ -8,9 +8,14 @@ PRICE_TABLE: Dict[str, Dict[str, float]] = {
     "gpt-4-turbo":       {"input": 0.01000,  "output": 0.03000},
     "gpt-4.1":           {"input": 0.00200,  "output": 0.00800,  "cached": 0.000500},
     "gpt-4.1-mini":      {"input": 0.00040,  "output": 0.00160,  "cached": 0.000100},
+    "gpt-4.1-nano":      {"input": 0.00010,  "output": 0.00040,  "cached": 0.000025},
     "o3":                {"input": 0.00200,  "output": 0.00800,  "cached": 0.000500},
     "o4-mini":           {"input": 0.00110,  "output": 0.00440,  "cached": 0.000275},
 
+    "text-embedding-3-small": {"input": 0.00002, "output": 0.0},
+    "text-embedding-3-large": {"input": 0.00013, "output": 0.0},
+    "text-embedding-ada-002": {"input": 0.00010, "output": 0.0},
+
     "claude-opus-4-6":   {"input": 0.00500,  "output": 0.02500,  "cached": 0.000500},
     "claude-sonnet-4-6": {"input": 0.00300,  "output": 0.01500,  "cached": 0.000300},
     "claude-haiku-4-5":  {"input": 0.00100,  "output": 0.00500,  "cached": 0.000100},
@@ -62,3 +67,24 @@ def calculate_cost(
 def _prefix_match(model: str, prices: Dict) -> Optional[Dict]:
     provider = model.split("/")[0] + "/*"
     return prices.get(provider)
+
+
+# Audio isn't token-billed: transcription is per-minute of input audio, TTS is
+# per-character of input text. gpt-4o-mini-tts's rate is an approximation
+# (not published on OpenAI's current pricing page as of 2026-07) — verify
+# against an actual invoice before trusting it for reconciliation.
+AUDIO_PRICE_TABLE: Dict[str, Dict[str, float]] = {
+    "whisper-1":       {"unit": "minute", "price": 0.006},
+    "gpt-4o-mini-tts": {"unit": "char",   "price": 0.000015},
+    "tts-1":           {"unit": "char",   "price": 0.000015},
+    "tts-1-hd":        {"unit": "char",   "price": 0.00003},
+}
+
+
+def calculate_audio_cost(model: str, *, minutes: float = 0.0, chars: int = 0) -> float:
+    entry = AUDIO_PRICE_TABLE.get(model)
+    if not entry:
+        return 0.0
+    if entry["unit"] == "minute":
+        return minutes * entry["price"]
+    return chars * entry["price"]

{tracecast-0.2.6 → tracecast-0.2.8}/tracecast/instrument.py

@@ -34,6 +34,24 @@ def auto_instrument(tracer: Optional[Tracer] = None) -> None:
         _instrumented = True
 
 
+def instrument_openai(*, chat: bool = True, embeddings: bool = True, audio: bool = True) -> None:
+    """Patch only the requested OpenAI API surfaces, independent of auto_instrument().
+
+    Use `chat=False` when chat completions are already traced through another
+    mechanism (e.g. a manually-wired LangChain callback) and you only want to
+    add embeddings/audio coverage — re-patching chat.completions in that case
+    would produce duplicate spans for every chat call.
+    """
+    from .instrumentors.openai_inst import OpenAIInstrumentor
+    with _lock:
+        inst = _registry.get("openai")
+        if inst is None:
+            inst = OpenAIInstrumentor()
+            _registry["openai"] = inst
+        if not inst.is_patched():
+            inst.patch(chat=chat, embeddings=embeddings, audio=audio)
+
+
 def _reset() -> None:
     global _instrumented
     with _lock:

tracecast-0.2.8/tracecast/instrumentors/openai_inst.py

@@ -0,0 +1,351 @@
+import sys
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Optional
+from .base import BaseInstrumentor, active_parent_id
+
+
+def _handled_by_langchain() -> bool:
+    from ..instrument import _registry
+
+    inst = _registry.get("langchain")
+    if inst is None or not inst.is_patched():
+        return False
+    frame = sys._getframe(2)
+    depth = 0
+    while frame is not None and depth < 60:
+        module = frame.f_globals.get("__name__", "")
+        if module.startswith("langchain"):
+            return True
+        frame = frame.f_back
+        depth += 1
+    return False
+
+
+class OpenAIInstrumentor(BaseInstrumentor):
+
+    def __init__(self) -> None:
+        self._original_create: Optional[Any] = None
+        self._original_acreate: Optional[Any] = None
+        self._original_embeddings_create: Optional[Any] = None
+        self._original_transcriptions_create: Optional[Any] = None
+        self._original_speech_create: Optional[Any] = None
+        self._patched: bool = False
+
+    def patch(self, *, chat: bool = True, embeddings: bool = True, audio: bool = True) -> None:
+        """Patch the requested OpenAI API surfaces.
+
+        `chat=False` lets callers add embeddings/audio coverage without
+        re-patching chat.completions — needed when chat completions are
+        already traced through another mechanism (e.g. a manually-wired
+        LangChain callback), where re-patching would double-count spans.
+        """
+        if self._patched:
+            return
+
+        if chat:
+            import openai.resources.chat.completions as mod
+
+            # Sync
+            self._original_create = mod.Completions.create
+            self_ref = self
+            _orig_create = self._original_create
+
+            def patched_create(client_self, *args, **kwargs):
+                return self_ref._intercept(client_self, args, kwargs, _orig_create)
+
+            mod.Completions.create = patched_create
+
+            # Async
+            if hasattr(mod, "AsyncCompletions"):
+                self._original_acreate = mod.AsyncCompletions.create
+                _orig_acreate = self._original_acreate
+
+                async def patched_acreate(client_self, *args, **kwargs):
+                    return await self_ref._async_intercept(client_self, args, kwargs, _orig_acreate)
+
+                mod.AsyncCompletions.create = patched_acreate
+
+        if embeddings:
+            self._patch_embeddings()
+        if audio:
+            self._patch_audio()
+
+        self._patched = True
+
+    def _patch_embeddings(self) -> None:
+        try:
+            import openai.resources.embeddings as emb_mod
+        except ImportError:
+            return
+        self._original_embeddings_create = emb_mod.Embeddings.create
+        self_ref = self
+        _orig = self._original_embeddings_create
+
+        def patched(client_self, *args, **kwargs):
+            return self_ref._intercept_embeddings(client_self, args, kwargs, _orig)
+
+        emb_mod.Embeddings.create = patched
+
+    def _patch_audio(self) -> None:
+        try:
+            import openai.resources.audio.transcriptions as tr_mod
+        except ImportError:
+            tr_mod = None
+        if tr_mod is not None:
+            self._original_transcriptions_create = tr_mod.Transcriptions.create
+            self_ref = self
+            _orig = self._original_transcriptions_create
+
+            def patched_tr(client_self, *args, **kwargs):
+                return self_ref._intercept_transcription(client_self, args, kwargs, _orig)
+
+            tr_mod.Transcriptions.create = patched_tr
+
+        try:
+            import openai.resources.audio.speech as sp_mod
+        except ImportError:
+            sp_mod = None
+        if sp_mod is not None:
+            self._original_speech_create = sp_mod.Speech.create
+            self_ref = self
+            _orig_sp = self._original_speech_create
+
+            def patched_sp(client_self, *args, **kwargs):
+                return self_ref._intercept_speech(client_self, args, kwargs, _orig_sp)
+
+            sp_mod.Speech.create = patched_sp
+
+    def unpatch(self) -> None:
+        if not self._patched:
+            return
+        if self._original_create is not None:
+            import openai.resources.chat.completions as mod
+            mod.Completions.create = self._original_create
+            if self._original_acreate is not None:
+                mod.AsyncCompletions.create = self._original_acreate
+            self._original_create = None
+            self._original_acreate = None
+
+        if self._original_embeddings_create is not None:
+            import openai.resources.embeddings as emb_mod
+            emb_mod.Embeddings.create = self._original_embeddings_create
+            self._original_embeddings_create = None
+
+        if self._original_transcriptions_create is not None:
+            import openai.resources.audio.transcriptions as tr_mod
+            tr_mod.Transcriptions.create = self._original_transcriptions_create
+            self._original_transcriptions_create = None
+
+        if self._original_speech_create is not None:
+            import openai.resources.audio.speech as sp_mod
+            sp_mod.Speech.create = self._original_speech_create
+            self._original_speech_create = None
+
+        self._patched = False
+
+    def is_patched(self) -> bool:
+        return self._patched
+
+    def _intercept(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
+        from ..core.tracer import Tracer
+        trace = Tracer.current()
+        if trace is None or _handled_by_langchain():
+            return original_fn(client_self, *args, **kwargs)
+        return self._capture(client_self, args, kwargs, original_fn, trace)
+
+    def _capture(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any, trace: Any) -> Any:
+        from ..models.span import Span, SpanType
+        from ..core.token_counter import extract_tokens, extract_content, extract_input_text
+        from ..core.cost_calculator import calculate_cost
+
+        model = kwargs.get("model", "unknown")
+        input_text = extract_input_text(kwargs, "openai")
+
+        span = Span(
+            span_id=str(uuid.uuid4()),
+            parent_span_id=active_parent_id(),
+            type=SpanType.LLM,
+            name=f"llm:{model}",
+            model=model,
+            started_at=datetime.now(timezone.utc),
+            input=input_text,
+        )
+
+        if kwargs.get("stream"):
+            from ._streaming import stream_openai
+            kwargs.setdefault("stream_options", {"include_usage": True})
+            raw = original_fn(client_self, *args, **kwargs)
+            return stream_openai(raw, span, trace, model)
+
+        try:
+            response = original_fn(client_self, *args, **kwargs)
+        except Exception as exc:
+            span.finished_at = datetime.now(timezone.utc)
+            span.mark_error(exc)
+            trace.spans.append(span)
+            raise
+
+        span.finished_at = datetime.now(timezone.utc)
+        tokens = extract_tokens(response, "openai")
+        span.tokens_in = int(tokens["input"])
+        span.tokens_out = int(tokens["output"])
+        span.tokens_in_cached = int(tokens.get("cached", 0))
+        span.cost_usd = calculate_cost(
+            model, span.tokens_in, span.tokens_out, tokens_in_cached=span.tokens_in_cached
+        )
+        span.output = extract_content(response, "openai")
+        trace.spans.append(span)
+
+        return response
+
+    async def _async_intercept(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
+        from ..core.tracer import Tracer
+        trace = Tracer.current()
+        if trace is None or _handled_by_langchain():
+            return await original_fn(client_self, *args, **kwargs)
+        return await self._async_capture(client_self, args, kwargs, original_fn, trace)
+
+    async def _async_capture(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any, trace: Any) -> Any:
+        from ..models.span import Span, SpanType
+        from ..core.token_counter import extract_tokens, extract_content, extract_input_text
+        from ..core.cost_calculator import calculate_cost
+
+        model = kwargs.get("model", "unknown")
+        input_text = extract_input_text(kwargs, "openai")
+
+        span = Span(
+            span_id=str(uuid.uuid4()),
+            parent_span_id=active_parent_id(),
+            type=SpanType.LLM,
+            name=f"llm:{model}",
+            model=model,
+            started_at=datetime.now(timezone.utc),
+            input=input_text,
+        )
+
+        if kwargs.get("stream"):
+            from ._streaming import astream_openai
+            kwargs.setdefault("stream_options", {"include_usage": True})
+            raw = await original_fn(client_self, *args, **kwargs)
+            return astream_openai(raw, span, trace, model)
+
+        try:
+            response = await original_fn(client_self, *args, **kwargs)
+        except Exception as exc:
+            span.finished_at = datetime.now(timezone.utc)
+            span.mark_error(exc)
+            trace.spans.append(span)
+            raise
+
+        span.finished_at = datetime.now(timezone.utc)
+        tokens = extract_tokens(response, "openai")
+        span.tokens_in = int(tokens["input"])
+        span.tokens_out = int(tokens["output"])
+        span.tokens_in_cached = int(tokens.get("cached", 0))
+        span.cost_usd = calculate_cost(
+            model, span.tokens_in, span.tokens_out, tokens_in_cached=span.tokens_in_cached
+        )
+        span.output = extract_content(response, "openai")
+        trace.spans.append(span)
+        return response
+
+    def _intercept_embeddings(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
+        from ..core.tracer import Tracer
+        trace = Tracer.current()
+        if trace is None or _handled_by_langchain():
+            return original_fn(client_self, *args, **kwargs)
+
+        from ..models.span import Span, SpanType
+        from ..core.cost_calculator import calculate_cost
+
+        model = kwargs.get("model", "unknown")
+        span = Span(
+            span_id=str(uuid.uuid4()),
+            parent_span_id=active_parent_id(),
+            type=SpanType.EMBEDDING,
+            name=f"embedding:{model}",
+            model=model,
+            started_at=datetime.now(timezone.utc),
+        )
+        try:
+            response = original_fn(client_self, *args, **kwargs)
+        except Exception as exc:
+            span.finished_at = datetime.now(timezone.utc)
+            span.mark_error(exc)
+            trace.spans.append(span)
+            raise
+
+        span.finished_at = datetime.now(timezone.utc)
+        usage = getattr(response, "usage", None)
+        span.tokens_in = int(getattr(usage, "prompt_tokens", 0) or 0) if usage else 0
+        span.cost_usd = calculate_cost(model, span.tokens_in, 0)
+        trace.spans.append(span)
+        return response
+
+    def _intercept_transcription(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
+        from ..core.tracer import Tracer
+        trace = Tracer.current()
+        if trace is None:
+            return original_fn(client_self, *args, **kwargs)
+
+        from ..models.span import Span, SpanType
+        from ..core.cost_calculator import calculate_audio_cost
+
+        model = kwargs.get("model", "unknown")
+        span = Span(
+            span_id=str(uuid.uuid4()),
+            parent_span_id=active_parent_id(),
+            type=SpanType.AUDIO,
+            name=f"audio:{model}",
+            model=model,
+            started_at=datetime.now(timezone.utc),
+        )
+        try:
+            response = original_fn(client_self, *args, **kwargs)
+        except Exception as exc:
+            span.finished_at = datetime.now(timezone.utc)
+            span.mark_error(exc)
+            trace.spans.append(span)
+            raise
+
+        span.finished_at = datetime.now(timezone.utc)
+        duration = getattr(response, "duration", None)
+        if duration is not None:
+            span.metadata["duration_seconds"] = duration
+            span.cost_usd = calculate_audio_cost(model, minutes=duration / 60)
+        trace.spans.append(span)
+        return response
+
+    def _intercept_speech(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
+        from ..core.tracer import Tracer
+        trace = Tracer.current()
+        if trace is None:
+            return original_fn(client_self, *args, **kwargs)
+
+        from ..models.span import Span, SpanType
+        from ..core.cost_calculator import calculate_audio_cost
+
+        model = kwargs.get("model", "unknown")
+        char_count = len(kwargs.get("input", "") or "")
+        span = Span(
+            span_id=str(uuid.uuid4()),
+            parent_span_id=active_parent_id(),
+            type=SpanType.AUDIO,
+            name=f"audio:{model}",
+            model=model,
+            started_at=datetime.now(timezone.utc),
+            metadata={"char_count": char_count},
+        )
+        try:
+            response = original_fn(client_self, *args, **kwargs)
+        except Exception as exc:
+            span.finished_at = datetime.now(timezone.utc)
+            span.mark_error(exc)
+            trace.spans.append(span)
+            raise
+
+        span.finished_at = datetime.now(timezone.utc)
+        span.cost_usd = calculate_audio_cost(model, chars=char_count)
+        trace.spans.append(span)
+        return response

{tracecast-0.2.6 → tracecast-0.2.8}/tracecast/models/span.py

@@ -5,9 +5,11 @@ from typing import Optional, Dict, Any
 
 
 class SpanType(str, Enum):
-    LLM   = "llm"
-    TOOL  = "tool"
-    AGENT = "agent"
+    LLM       = "llm"
+    TOOL      = "tool"
+    AGENT     = "agent"
+    EMBEDDING = "embedding"
+    AUDIO     = "audio"
 
 
 class SpanStatus(str, Enum):

{tracecast-0.2.6 → tracecast-0.2.8}/tracecast.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tracecast
-Version: 0.2.6
+Version: 0.2.8
 Summary: LLM observability SDK — framework-agnostic tracing for AI applications
 Author: Pedro Castanheira Costa
 License: MIT

tracecast-0.2.6/tracecast/instrumentors/openai_inst.py

@@ -1,174 +0,0 @@
-import sys
-import uuid
-from datetime import datetime, timezone
-from typing import Any, Optional
-from .base import BaseInstrumentor, active_parent_id
-
-
-def _handled_by_langchain() -> bool:
-    from ..instrument import _registry
-
-    inst = _registry.get("langchain")
-    if inst is None or not inst.is_patched():
-        return False
-    frame = sys._getframe(2)
-    depth = 0
-    while frame is not None and depth < 60:
-        module = frame.f_globals.get("__name__", "")
-        if module.startswith("langchain"):
-            return True
-        frame = frame.f_back
-        depth += 1
-    return False
-
-
-class OpenAIInstrumentor(BaseInstrumentor):
-
-    def __init__(self) -> None:
-        self._original_create: Optional[Any] = None
-        self._original_acreate: Optional[Any] = None
-        self._patched: bool = False
-
-    def patch(self) -> None:
-        if self._patched:
-            return
-        import openai.resources.chat.completions as mod
-
-        # Sync
-        self._original_create = mod.Completions.create
-        self_ref = self
-        _orig_create = self._original_create
-
-        def patched_create(client_self, *args, **kwargs):
-            return self_ref._intercept(client_self, args, kwargs, _orig_create)
-
-        mod.Completions.create = patched_create
-
-        # Async
-        if hasattr(mod, "AsyncCompletions"):
-            self._original_acreate = mod.AsyncCompletions.create
-            _orig_acreate = self._original_acreate
-
-            async def patched_acreate(client_self, *args, **kwargs):
-                return await self_ref._async_intercept(client_self, args, kwargs, _orig_acreate)
-
-            mod.AsyncCompletions.create = patched_acreate
-
-        self._patched = True
-
-    def unpatch(self) -> None:
-        if not self._patched:
-            return
-        import openai.resources.chat.completions as mod
-        mod.Completions.create = self._original_create
-        if self._original_acreate is not None:
-            mod.AsyncCompletions.create = self._original_acreate
-        self._original_create = None
-        self._original_acreate = None
-        self._patched = False
-
-    def is_patched(self) -> bool:
-        return self._patched
-
-    def _intercept(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
-        from ..core.tracer import Tracer
-        trace = Tracer.current()
-        if trace is None or _handled_by_langchain():
-            return original_fn(client_self, *args, **kwargs)
-        return self._capture(client_self, args, kwargs, original_fn, trace)
-
-    def _capture(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any, trace: Any) -> Any:
-        from ..models.span import Span, SpanType
-        from ..core.token_counter import extract_tokens, extract_content, extract_input_text
-        from ..core.cost_calculator import calculate_cost
-
-        model = kwargs.get("model", "unknown")
-        input_text = extract_input_text(kwargs, "openai")
-
-        span = Span(
-            span_id=str(uuid.uuid4()),
-            parent_span_id=active_parent_id(),
-            type=SpanType.LLM,
-            name=f"llm:{model}",
-            model=model,
-            started_at=datetime.now(timezone.utc),
-            input=input_text,
-        )
-
-        if kwargs.get("stream"):
-            from ._streaming import stream_openai
-            kwargs.setdefault("stream_options", {"include_usage": True})
-            raw = original_fn(client_self, *args, **kwargs)
-            return stream_openai(raw, span, trace, model)
-
-        try:
-            response = original_fn(client_self, *args, **kwargs)
-        except Exception as exc:
-            span.finished_at = datetime.now(timezone.utc)
-            span.mark_error(exc)
-            trace.spans.append(span)
-            raise
-
-        span.finished_at = datetime.now(timezone.utc)
-        tokens = extract_tokens(response, "openai")
-        span.tokens_in = int(tokens["input"])
-        span.tokens_out = int(tokens["output"])
-        span.tokens_in_cached = int(tokens.get("cached", 0))
-        span.cost_usd = calculate_cost(
-            model, span.tokens_in, span.tokens_out, tokens_in_cached=span.tokens_in_cached
-        )
-        span.output = extract_content(response, "openai")
-        trace.spans.append(span)
-
-        return response
-
-    async def _async_intercept(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any) -> Any:
-        from ..core.tracer import Tracer
-        trace = Tracer.current()
-        if trace is None or _handled_by_langchain():
-            return await original_fn(client_self, *args, **kwargs)
-        return await self._async_capture(client_self, args, kwargs, original_fn, trace)
-
-    async def _async_capture(self, client_self: Any, args: tuple, kwargs: dict, original_fn: Any, trace: Any) -> Any:
-        from ..models.span import Span, SpanType
-        from ..core.token_counter import extract_tokens, extract_content, extract_input_text
-        from ..core.cost_calculator import calculate_cost
-
-        model = kwargs.get("model", "unknown")
-        input_text = extract_input_text(kwargs, "openai")
-
-        span = Span(
-            span_id=str(uuid.uuid4()),
-            parent_span_id=active_parent_id(),
-            type=SpanType.LLM,
-            name=f"llm:{model}",
-            model=model,
-            started_at=datetime.now(timezone.utc),
-            input=input_text,
-        )
-
-        if kwargs.get("stream"):
-            from ._streaming import astream_openai
-            kwargs.setdefault("stream_options", {"include_usage": True})
-            raw = await original_fn(client_self, *args, **kwargs)
-            return astream_openai(raw, span, trace, model)
-
-        try:
-            response = await original_fn(client_self, *args, **kwargs)
-        except Exception as exc:
-            span.finished_at = datetime.now(timezone.utc)
-            span.mark_error(exc)
-            trace.spans.append(span)
-            raise
-
-        span.finished_at = datetime.now(timezone.utc)
-        tokens = extract_tokens(response, "openai")
-        span.tokens_in = int(tokens["input"])
-        span.tokens_out = int(tokens["output"])
-        span.tokens_in_cached = int(tokens.get("cached", 0))
-        span.cost_usd = calculate_cost(
-            model, span.tokens_in, span.tokens_out, tokens_in_cached=span.tokens_in_cached
-        )
-        span.output = extract_content(response, "openai")
-        trace.spans.append(span)
-        return response