a2a-llm-tracker 0.0.1__tar.gz

a2a_llm_tracker-0.0.1/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: a2a-llm-tracker
+Version: 0.0.1
+Summary: A short description of your package
+Author-email: Nischal Bhandari <nischal@boomconsole.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: mftsccs
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: python-dotenv; extra == "dev"
+Requires-Dist: litellm; extra == "dev"
+
+# a2a-tracker

a2a_llm_tracker-0.0.1/README.md

@@ -0,0 +1 @@
+# a2a-tracker

a2a_llm_tracker-0.0.1/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "a2a-llm-tracker" # PyPI name uses hyphens; the import name uses underscores
+version = "0.0.1"
+authors = [
+    { name = "Nischal Bhandari", email = "nischal@boomconsole.com" }
+]
+description = "A short description of your package"
+readme = "README.md"
+requires-python = ">=3.6"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "mftsccs"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0",
+    "twine",
+    "python-dotenv",
+    "litellm"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+
+[tool.black]
+line-length = 88
+target-version = ["py38", "py39", "py310", "py311", "py312"]
+
+[tool.ruff]
+line-length = 88
+select = ["E", "F", "I", "N", "W", "UP"]
+
+[tool.mypy]
+python_version = "3.8"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"

a2a_llm_tracker-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/__init__.py

@@ -0,0 +1,6 @@
+
+from .context import meter_context, set_context
+from .meter import Meter
+from .pricing import PricingRegistry
+
+__all__ = ["Meter", "PricingRegistry", "meter_context", "set_context"]

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/__main__.py

@@ -0,0 +1,95 @@
+"""
+Manual smoke-test runner for agent_meter.
+
+Usage:
+  OPENAI_API_KEY=... python -m agent_meter
+"""
+
+import asyncio
+import os
+
+from a2a_llm_tracker  import Meter, PricingRegistry, meter_context
+from a2a_llm_tracker.integrations.litellm import LiteLLM
+from a2a_llm_tracker.sinks.jsonl import JSONLSink
+from dotenv import load_dotenv
+load_dotenv()
+
+def setup_meter() -> LiteLLM:
+    pricing = PricingRegistry()
+
+    # Example prices — adjust as needed
+    pricing.set_price(
+        provider="openai",
+        model="openai/gpt-4.1",
+        input_per_million=2.0,
+        output_per_million=8.0,
+    )
+
+    meter = Meter(
+        pricing=pricing,
+        sinks=[JSONLSink("debug_usage.jsonl")],
+        project="agent-meter-smoke-test",
+    )
+
+    return LiteLLM(meter=meter)
+
+
+def run_sync(llm: LiteLLM) -> None:
+    print("\n=== SYNC NON-STREAMING ===")
+    resp = llm.completion(
+        model="openai/gpt-4.1",
+        messages=[{"role": "user", "content": "Say hello in one sentence."}],
+    )
+    print(resp)
+
+
+def run_stream(llm: LiteLLM) -> None:
+    print("\n=== SYNC STREAMING ===")
+    for chunk in llm.completion(
+        model="openai/gpt-4.1",
+        messages=[{"role": "user", "content": "Write a short haiku about testing."}],
+        stream=True,
+    ):
+        print(chunk, end="", flush=True)
+    print()
+
+
+async def run_async(llm: LiteLLM) -> None:
+    print("\n=== ASYNC NON-STREAMING ===")
+    resp = await llm.acompletion(
+        model="openai/gpt-4.1",
+        messages=[{"role": "user", "content": "Async hello!"}],
+    )
+    print(resp)
+
+
+async def run_async_stream(llm: LiteLLM) -> None:
+    print("\n=== ASYNC STREAMING ===")
+    stream = await llm.acompletion(
+        model="openai/gpt-4.1",
+        messages=[{"role": "user", "content": "Stream something async."}],
+        stream=True,
+    )
+    async for chunk in stream:
+        print(chunk, end="", flush=True)
+    print()
+
+
+def main() -> None:
+    if not os.getenv("OPENAI_API_KEY"):
+        print("⚠️  OPENAI_API_KEY is not set. Exiting.")
+        return
+
+    llm = setup_meter()
+
+    with meter_context(agent_id="smoke-test-agent", session_id="local"):
+        run_sync(llm)
+        run_stream(llm)
+        asyncio.run(run_async(llm))
+        asyncio.run(run_async_stream(llm))
+
+    print("\n✔ Smoke test complete. Check debug_usage.jsonl")
+
+
+if __name__ == "__main__":
+    main()

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/context.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Iterator, Optional
+
+
+@dataclass(frozen=True)
+class MeterContext:
+    agent_id: Optional[str] = None
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+    trace_id: Optional[str] = None
+
+
+_CTX: ContextVar[MeterContext] = ContextVar("agent_meter_context", default=MeterContext())
+
+
+def get_context() -> MeterContext:
+    return _CTX.get()
+
+
+def set_context(
+    *,
+    agent_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+    trace_id: Optional[str] = None,
+) -> None:
+    current = _CTX.get()
+    _CTX.set(
+        MeterContext(
+            agent_id=agent_id if agent_id is not None else current.agent_id,
+            user_id=user_id if user_id is not None else current.user_id,
+            session_id=session_id if session_id is not None else current.session_id,
+            trace_id=trace_id if trace_id is not None else current.trace_id,
+        )
+    )
+
+
+@contextmanager
+def meter_context(
+    *,
+    agent_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+    trace_id: Optional[str] = None,
+) -> Iterator[None]:
+    token = _CTX.set(
+        MeterContext(agent_id=agent_id, user_id=user_id, session_id=session_id, trace_id=trace_id)
+    )
+    try:
+        yield
+    finally:
+        _CTX.reset(token)

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/core.py

@@ -0,0 +1,2 @@
+def hello(name: str) -> str:
+    return f"Hello, {name}!"    

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/events.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+
+def utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+@dataclass
+class UsageEvent:
+    provider: str
+    model: str
+
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+
+    input_cost_usd: Optional[float] = None
+    output_cost_usd: Optional[float] = None
+    cost_usd: Optional[float] = None
+
+    accuracy: str = "unknown"  # "exact" | "estimated" | "unknown"
+
+    request_id: Optional[str] = None
+    latency_ms: Optional[int] = None
+    status: str = "ok"  # "ok" | "error"
+    error_type: Optional[str] = None
+    error_message: Optional[str] = None
+
+    ts: datetime = field(default_factory=utcnow)
+
+    # attribution
+    agent_id: Optional[str] = None
+    user_id: Optional[str] = None
+    session_id: Optional[str] = None
+    trace_id: Optional[str] = None
+
+    metadata: dict[str, Any] = field(default_factory=dict)

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/integrations/__init__.py

@@ -0,0 +1,3 @@
+from .litellm import LiteLLM
+
+__all__ = ["LiteLLM"]

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/integrations/litellm.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+import time
+from typing import Any, AsyncIterator, Iterator, Optional, Tuple
+
+from ..events import UsageEvent
+from ..meter import Meter
+
+
+def _get_attr(obj: Any, name: str, default: Any = None) -> Any:
+    # works for dicts and objects
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return getattr(obj, name, default)
+
+
+def _extract_usage(resp_or_chunk: Any) -> Tuple[Optional[int], Optional[int], Optional[int]]:
+    """
+    LiteLLM often returns a response with:
+      - resp.usage.prompt_tokens / completion_tokens / total_tokens
+    For streaming, some configs return usage in the final chunk.
+    """
+    usage = _get_attr(resp_or_chunk, "usage", None)
+    if usage is None:
+        # sometimes nested differently; keep this minimal for v1
+        return None, None, None
+
+    in_tok = _get_attr(usage, "prompt_tokens", None)
+    out_tok = _get_attr(usage, "completion_tokens", None)
+    total = _get_attr(usage, "total_tokens", None)
+
+    # Sometimes LiteLLM usage might be dict-like
+    if isinstance(usage, dict):
+        in_tok = usage.get("prompt_tokens", in_tok)
+        out_tok = usage.get("completion_tokens", out_tok)
+        total = usage.get("total_tokens", total)
+
+    return in_tok, out_tok, total
+
+
+def _guess_provider_from_model(model: str) -> str:
+    """
+    LiteLLM supports prefixes like 'openai/gpt-4o-mini', 'anthropic/claude-...'.
+    If absent, we default to 'litellm'.
+    """
+    if "/" in model:
+        return model.split("/", 1)[0].lower()
+    if ":" in model:
+        return model.split(":", 1)[0].lower()
+    return "litellm"
+
+
+class _StreamWrapper(Iterator[Any]):
+    def __init__(self, inner: Iterator[Any], finalize) -> None:
+        self._inner = inner
+        self._finalize = finalize
+        self._done = False
+
+    def __iter__(self) -> "_StreamWrapper":
+        return self
+
+    def __next__(self) -> Any:
+        try:
+            return next(self._inner)
+        except StopIteration:
+            if not self._done:
+                self._done = True
+                self._finalize()
+            raise
+        except Exception:
+            if not self._done:
+                self._done = True
+                self._finalize(error=True)
+            raise
+
+
+class _AsyncStreamWrapper(AsyncIterator[Any]):
+    def __init__(self, inner: AsyncIterator[Any], finalize) -> None:
+        self._inner = inner
+        self._finalize = finalize
+        self._done = False
+
+    def __aiter__(self) -> "_AsyncStreamWrapper":
+        return self
+
+    async def __anext__(self) -> Any:
+        try:
+            return await self._inner.__anext__()
+        except StopAsyncIteration:
+            if not self._done:
+                self._done = True
+                self._finalize()
+            raise
+        except Exception:
+            if not self._done:
+                self._done = True
+                self._finalize(error=True)
+            raise
+
+
+class LiteLLM:
+    """
+    LiteLLM-first wrapper.
+    - completion(): sync
+    - acompletion(): async
+    Supports stream=True and stream=False.
+    """
+
+    def __init__(self, *, meter: Meter) -> None:
+        self.meter = meter
+
+        try:
+            import litellm  # type: ignore
+        except Exception as e:
+            raise RuntimeError(
+                "litellm is not installed. Install with: pip install -e '.[litellm]'"
+            ) from e
+
+        self._litellm = litellm
+
+    def completion(self, **kwargs: Any):
+        """
+        Mirrors litellm.completion(**kwargs).
+        If stream=True, returns an iterator you can for-loop; event is recorded when stream ends.
+        """
+        model = kwargs.get("model", "unknown")
+        provider = _guess_provider_from_model(model)
+
+        stream = bool(kwargs.get("stream", False))
+
+        # Best effort: ask for usage in streaming if supported by downstream.
+        # Not all providers respect this; we still handle missing usage.
+        kwargs.setdefault("stream_options", {"include_usage": True})
+
+        t0 = time.time()
+        last_chunk_holder: dict[str, Any] = {"last": None}
+        status = "ok"
+        err_type = None
+        err_msg = None
+        request_id: Optional[str] = None
+        final_model: str = model
+
+        def finalize(error: bool = False) -> None:
+            latency_ms = int((time.time() - t0) * 1000)
+
+            resp_or_chunk = last_chunk_holder["last"]
+            in_tok = out_tok = total = None
+
+            if resp_or_chunk is not None:
+                in_tok, out_tok, total = _extract_usage(resp_or_chunk)
+                request_id_local = _get_attr(resp_or_chunk, "id", None)
+                nonlocal request_id, final_model
+                if request_id is None:
+                    request_id = request_id_local
+                final_model = _get_attr(resp_or_chunk, "model", final_model) or final_model
+
+            accuracy = "exact" if (in_tok is not None and out_tok is not None) else "unknown"
+            in_cost, out_cost, cost, _price = self.meter.compute_cost(provider, final_model, in_tok, out_tok)
+
+            event = UsageEvent(
+                provider=provider,
+                model=final_model,
+                input_tokens=in_tok,
+                output_tokens=out_tok,
+                total_tokens=total,
+                input_cost_usd=in_cost,
+                output_cost_usd=out_cost,
+                cost_usd=cost,
+                accuracy=accuracy,
+                request_id=request_id,
+                latency_ms=latency_ms,
+                status="error" if error else status,
+                error_type=err_type,
+                error_message=err_msg,
+                metadata={"integration": "litellm", "stream": stream},
+            )
+            self.meter.record(event)
+
+        try:
+            resp = self._litellm.completion(**kwargs)
+            if not stream:
+                latency_ms = int((time.time() - t0) * 1000)
+
+                request_id = _get_attr(resp, "id", None)
+                final_model = _get_attr(resp, "model", model) or model
+                in_tok, out_tok, total = _extract_usage(resp)
+
+                accuracy = "exact" if (in_tok is not None and out_tok is not None) else "unknown"
+                in_cost, out_cost, cost, _price = self.meter.compute_cost(provider, final_model, in_tok, out_tok)
+
+                self.meter.record(
+                    UsageEvent(
+                        provider=provider,
+                        model=final_model,
+                        input_tokens=in_tok,
+                        output_tokens=out_tok,
+                        total_tokens=total,
+                        input_cost_usd=in_cost,
+                        output_cost_usd=out_cost,
+                        cost_usd=cost,
+                        accuracy=accuracy,
+                        request_id=request_id,
+                        latency_ms=latency_ms,
+                        status="ok",
+                        metadata={"integration": "litellm", "stream": False},
+                    )
+                )
+                return resp
+
+            # stream=True
+            def gen():
+                for chunk in resp:
+                    last_chunk_holder["last"] = chunk
+                    yield chunk
+
+            return _StreamWrapper(gen(), finalize)
+
+        except Exception as e:
+            status = "error"
+            err_type = type(e).__name__
+            err_msg = str(e)
+            finalize(error=True)
+            raise
+
+    async def acompletion(self, **kwargs: Any):
+        """
+        Mirrors litellm.acompletion(**kwargs).
+        If stream=True, returns an async iterator; event is recorded when stream ends.
+        """
+        model = kwargs.get("model", "unknown")
+        provider = _guess_provider_from_model(model)
+        stream = bool(kwargs.get("stream", False))
+
+        kwargs.setdefault("stream_options", {"include_usage": True})
+
+        t0 = time.time()
+        last_chunk_holder: dict[str, Any] = {"last": None}
+        status = "ok"
+        err_type = None
+        err_msg = None
+        request_id: Optional[str] = None
+        final_model: str = model
+
+        def finalize(error: bool = False) -> None:
+            latency_ms = int((time.time() - t0) * 1000)
+
+            resp_or_chunk = last_chunk_holder["last"]
+            in_tok = out_tok = total = None
+
+            if resp_or_chunk is not None:
+                in_tok, out_tok, total = _extract_usage(resp_or_chunk)
+                request_id_local = _get_attr(resp_or_chunk, "id", None)
+                nonlocal request_id, final_model
+                if request_id is None:
+                    request_id = request_id_local
+                final_model = _get_attr(resp_or_chunk, "model", final_model) or final_model
+
+            accuracy = "exact" if (in_tok is not None and out_tok is not None) else "unknown"
+            in_cost, out_cost, cost, _price = self.meter.compute_cost(provider, final_model, in_tok, out_tok)
+
+            event = UsageEvent(
+                provider=provider,
+                model=final_model,
+                input_tokens=in_tok,
+                output_tokens=out_tok,
+                total_tokens=total,
+                input_cost_usd=in_cost,
+                output_cost_usd=out_cost,
+                cost_usd=cost,
+                accuracy=accuracy,
+                request_id=request_id,
+                latency_ms=latency_ms,
+                status="error" if error else status,
+                error_type=err_type,
+                error_message=err_msg,
+                metadata={"integration": "litellm", "stream": stream, "async": True},
+            )
+            self.meter.record(event)
+
+        try:
+            resp = await self._litellm.acompletion(**kwargs)
+            if not stream:
+                latency_ms = int((time.time() - t0) * 1000)
+
+                request_id = _get_attr(resp, "id", None)
+                final_model = _get_attr(resp, "model", model) or model
+                in_tok, out_tok, total = _extract_usage(resp)
+
+                accuracy = "exact" if (in_tok is not None and out_tok is not None) else "unknown"
+                in_cost, out_cost, cost, _price = self.meter.compute_cost(provider, final_model, in_tok, out_tok)
+
+                self.meter.record(
+                    UsageEvent(
+                        provider=provider,
+                        model=final_model,
+                        input_tokens=in_tok,
+                        output_tokens=out_tok,
+                        total_tokens=total,
+                        input_cost_usd=in_cost,
+                        output_cost_usd=out_cost,
+                        cost_usd=cost,
+                        accuracy=accuracy,
+                        request_id=request_id,
+                        latency_ms=latency_ms,
+                        status="ok",
+                        metadata={"integration": "litellm", "stream": False, "async": True},
+                    )
+                )
+                return resp
+
+            # stream=True (async iterator)
+            async def agen():
+                async for chunk in resp:
+                    last_chunk_holder["last"] = chunk
+                    yield chunk
+
+            return _AsyncStreamWrapper(agen(), finalize)
+
+        except Exception as e:
+            status = "error"
+            err_type = type(e).__name__
+            err_msg = str(e)
+            finalize(error=True)
+            raise

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/meter.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+from .context import get_context
+from .events import UsageEvent
+from .pricing import ModelPrice, PricingRegistry
+from .sinks.base import Sink
+
+
+class Meter:
+    def __init__(
+        self,
+        *,
+        pricing: Optional[PricingRegistry] = None,
+        sinks: Optional[Iterable[Sink]] = None,
+        project: Optional[str] = None,
+    ) -> None:
+        self.pricing = pricing or PricingRegistry()
+        self.sinks = list(sinks or [])
+        self.project = project
+
+    def compute_cost(
+        self,
+        provider: str,
+        model: str,
+        input_tokens: Optional[int],
+        output_tokens: Optional[int],
+    ) -> tuple[Optional[float], Optional[float], Optional[float], Optional[ModelPrice]]:
+        price = self.pricing.get_price(provider, model)
+        if price is None or input_tokens is None or output_tokens is None:
+            return None, None, None, price
+
+        in_cost = (input_tokens / 1_000_000) * price.input_per_million
+        out_cost = (output_tokens / 1_000_000) * price.output_per_million
+        return in_cost, out_cost, (in_cost + out_cost), price
+
+    def record(self, event: UsageEvent) -> None:
+        # enrich with context if missing
+        ctx = get_context()
+        event.agent_id = event.agent_id or ctx.agent_id
+        event.user_id = event.user_id or ctx.user_id
+        event.session_id = event.session_id or ctx.session_id
+        event.trace_id = event.trace_id or ctx.trace_id
+
+        if self.project:
+            event.metadata.setdefault("project", self.project)
+
+        for sink in self.sinks:
+            sink.write(event)

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/pricing.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class ModelPrice:
+    input_per_million: float
+    output_per_million: float
+
+
+class PricingRegistry:
+    """
+    Simple in-memory pricing table.
+    Users can override by calling `set_price`.
+    """
+
+    def __init__(self) -> None:
+        self._prices: dict[tuple[str, str], ModelPrice] = {}
+
+    def set_price(self, provider: str, model: str, *, input_per_million: float, output_per_million: float) -> None:
+        self._prices[(provider.lower(), model)] = ModelPrice(
+            input_per_million=float(input_per_million),
+            output_per_million=float(output_per_million),
+        )
+
+    def get_price(self, provider: str, model: str) -> Optional[ModelPrice]:
+        return self._prices.get((provider.lower(), model))

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/sinks/__init__.py

@@ -0,0 +1,5 @@
+from .base import Sink
+from .jsonl import JSONLSink
+from .sqlite import SQLiteSink
+
+__all__ = ["Sink", "JSONLSink", "SQLiteSink"]

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/sinks/base.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from ..events import UsageEvent
+
+
+class Sink(ABC):
+    @abstractmethod
+    def write(self, event: UsageEvent) -> None:
+        raise NotImplementedError

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/sinks/jsonl.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from .base import Sink
+from ..events import UsageEvent
+
+
+class JSONLSink(Sink):
+    def __init__(self, path: str) -> None:
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def write(self, event: UsageEvent) -> None:
+        d: dict[str, Any] = asdict(event)
+        # datetime -> iso
+        d["ts"] = event.ts.isoformat()
+        with self.path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(d, ensure_ascii=False) + "\n")

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker/sinks/sqlite.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, Optional
+
+from .base import Sink
+from ..events import UsageEvent
+
+
+class SQLiteSink(Sink):
+    def __init__(self, path: str = "usage.db") -> None:
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_db()
+
+    def _connect(self) -> sqlite3.Connection:
+        return sqlite3.connect(str(self.path))
+
+    def _init_db(self) -> None:
+        with self._connect() as conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS usage_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    ts TEXT,
+                    provider TEXT,
+                    model TEXT,
+                    input_tokens INTEGER,
+                    output_tokens INTEGER,
+                    total_tokens INTEGER,
+                    input_cost_usd REAL,
+                    output_cost_usd REAL,
+                    cost_usd REAL,
+                    accuracy TEXT,
+                    request_id TEXT,
+                    latency_ms INTEGER,
+                    status TEXT,
+                    error_type TEXT,
+                    error_message TEXT,
+                    agent_id TEXT,
+                    user_id TEXT,
+                    session_id TEXT,
+                    trace_id TEXT,
+                    metadata_json TEXT
+                )
+                """
+            )
+            conn.commit()
+
+    def write(self, event: UsageEvent) -> None:
+        d: dict[str, Any] = asdict(event)
+        metadata_json = None
+        try:
+            import json
+
+            metadata_json = json.dumps(d.get("metadata", {}), ensure_ascii=False)
+        except Exception:
+            metadata_json = "{}"
+
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO usage_events (
+                    ts, provider, model,
+                    input_tokens, output_tokens, total_tokens,
+                    input_cost_usd, output_cost_usd, cost_usd,
+                    accuracy, request_id, latency_ms,
+                    status, error_type, error_message,
+                    agent_id, user_id, session_id, trace_id,
+                    metadata_json
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    event.ts.isoformat(),
+                    event.provider,
+                    event.model,
+                    event.input_tokens,
+                    event.output_tokens,
+                    event.total_tokens,
+                    event.input_cost_usd,
+                    event.output_cost_usd,
+                    event.cost_usd,
+                    event.accuracy,
+                    event.request_id,
+                    event.latency_ms,
+                    event.status,
+                    event.error_type,
+                    event.error_message,
+                    event.agent_id,
+                    event.user_id,
+                    event.session_id,
+                    event.trace_id,
+                    metadata_json,
+                ),
+            )
+            conn.commit()

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: a2a-llm-tracker
+Version: 0.0.1
+Summary: A short description of your package
+Author-email: Nischal Bhandari <nischal@boomconsole.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: mftsccs
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: python-dotenv; extra == "dev"
+Requires-Dist: litellm; extra == "dev"
+
+# a2a-tracker

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+src/a2a_llm_tracker/__init__.py
+src/a2a_llm_tracker/__main__.py
+src/a2a_llm_tracker/context.py
+src/a2a_llm_tracker/core.py
+src/a2a_llm_tracker/events.py
+src/a2a_llm_tracker/meter.py
+src/a2a_llm_tracker/pricing.py
+src/a2a_llm_tracker.egg-info/PKG-INFO
+src/a2a_llm_tracker.egg-info/SOURCES.txt
+src/a2a_llm_tracker.egg-info/dependency_links.txt
+src/a2a_llm_tracker.egg-info/requires.txt
+src/a2a_llm_tracker.egg-info/top_level.txt
+src/a2a_llm_tracker/integrations/__init__.py
+src/a2a_llm_tracker/integrations/litellm.py
+src/a2a_llm_tracker/sinks/__init__.py
+src/a2a_llm_tracker/sinks/base.py
+src/a2a_llm_tracker/sinks/jsonl.py
+src/a2a_llm_tracker/sinks/sqlite.py
+tests/test_core.py

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker.egg-info/requires.txt

@@ -0,0 +1,11 @@
+mftsccs
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0
+black>=23.0
+ruff>=0.1.0
+mypy>=1.0
+twine
+python-dotenv
+litellm

a2a_llm_tracker-0.0.1/src/a2a_llm_tracker.egg-info/top_level.txt

@@ -0,0 +1 @@
+a2a_llm_tracker

a2a_llm_tracker-0.0.1/tests/test_core.py

@@ -0,0 +1,14 @@
+
+from a2a_llm_tracker import Meter, PricingRegistry
+from a2a_llm_tracker.sinks.sqlite import SQLiteSink
+from a2a_llm_tracker.integrations.litellm import LiteLLM
+
+
+def testing_registry():
+    pricing = PricingRegistry()
+    pricing.set_price("openai", "openai/gpt-4.1", input_per_million=2.0, output_per_million=8.0)
+    llm = LiteLLM(meter=meter)
+
+
+
+