tracecast 0.2.6__tar.gz → 0.2.7__tar.gz

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

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

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

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

{tracecast-0.2.6 → tracecast-0.2.7}/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.7}/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.7}/tracecast/instrumentors/openai_inst.py

@@ -27,6 +27,9 @@ 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) -> None:
@@ -54,8 +57,54 @@ class OpenAIInstrumentor(BaseInstrumentor):
 
             mod.AsyncCompletions.create = patched_acreate
 
+        self._patch_embeddings()
+        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
@@ -65,6 +114,22 @@ class OpenAIInstrumentor(BaseInstrumentor):
             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:
@@ -172,3 +237,103 @@ class OpenAIInstrumentor(BaseInstrumentor):
         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.7}/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.7}/tracecast.egg-info/PKG-INFO

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