scopecall-py 0.2.0__py3-none-any.whl

scopecall/__init__.py

@@ -0,0 +1,81 @@
+"""ScopeCall — source-available, self-hostable AI observability for Python.
+
+Quick start:
+
+    import scopecall
+    from openai import OpenAI
+
+    sdk = scopecall.init(
+        api_key="sc_live_xxx",
+        endpoint="http://localhost:8080/v1/ingest",
+    )
+
+    # Native OpenAI / Anthropic instrumentation:
+    openai_client = sdk.instrument(OpenAI())
+
+    with sdk.trace("support-agent", user_id="user_123") as ctx:
+        response = openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": "Help me with my refund"}],
+        )
+
+    # Manual API (LangChain / LlamaIndex / RAG / custom wrappers):
+    with sdk.trace("custom-agent", user_id="user_456"):
+        sdk.record_llm_call(
+            model="gpt-4o-mini",
+            provider="openai",
+            input_tokens=120, output_tokens=48,
+            latency_ms=842,
+            input_text="Help me with my refund",
+            output_text="...",
+        )
+
+    sdk.close()  # graceful shutdown — flushes the queue
+
+
+API surface:
+
+    init(...)          → ScopeCallSDK instance
+    ScopeCallSDK       → trace(name) / workflow(name) /
+                         instrument(client, provider="openai"|"anthropic") /
+                         record_llm_call(...) / add_redaction_pattern(...) /
+                         flush() / close()
+    ScopeCallConfig    → typed config dataclass for dependency-injection style
+    ConfigError        → raised when init() gets an invalid config
+    LLMEvent           → wire-format dataclass (advanced — usually emitted
+                         for you by record_llm_call or the instrumentations)
+
+
+Migrating from scopecall v0.1.x:
+
+  v0.1 used module-level globals (`scopecall.init(); scopecall.trace(...)`).
+  v0.2 returns an instance from `init()`. The two changes most likely to
+  break callers:
+
+    OLD:  scopecall.init(api_key="...")               # module-level
+          with scopecall.trace(feature="x"):
+              ...
+
+    NEW:  sdk = scopecall.init(api_key="...",         # endpoint REQUIRED now
+                               endpoint="http://localhost:8080/v1/ingest")
+          with sdk.trace("x"):                        # name is positional
+              ...
+
+  See CHANGELOG.md → v0.2.0 for the full migration guide.
+"""
+
+from ._config import ConfigError, ScopeCallConfig
+from ._context import TraceContext
+from ._sdk import ScopeCallSDK, init
+from ._version import __version__
+from .wire._event import LLMEvent
+
+__all__ = [
+    "init",
+    "ScopeCallSDK",
+    "ScopeCallConfig",
+    "ConfigError",
+    "TraceContext",
+    "LLMEvent",
+    "__version__",
+]

scopecall/_config.py

@@ -0,0 +1,129 @@
+"""SDK configuration.
+
+Matches the TS SDK's `ScopeCallConfig` shape (sdks/typescript/src/config.ts)
+field-for-field where it makes sense. Naming follows Python conventions
+(`snake_case`, `bool` defaults) — the field set itself is parity.
+
+Round-8 review made `endpoint` required when `api_key` is set: a missing
+endpoint used to silently default to https://ingest.scopecall.com/v1/ingest
+which doesn't exist yet (hosted Cloud isn't live). Python now follows the
+same contract — fail loud with a `ConfigError` that names the fix.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+class ConfigError(ValueError):
+    """Raised by `init(...)` when the config is internally inconsistent.
+
+    Subclasses `ValueError` so existing try/except blocks that catch the
+    base class still work; the named subclass lets careful callers
+    distinguish config errors from other ValueError sources.
+    """
+
+
+@dataclass
+class ScopeCallConfig:
+    # ── Transport selection ──────────────────────────────────────────────
+    # Exactly one of api_key / output / debug must be set. Mirrors TS.
+    api_key: str | None = None
+
+    # `endpoint` is REQUIRED when api_key is set (Round-8 review). For
+    # self-hosted, point at the Rust ingest URL, e.g.
+    # http://localhost:8080/v1/ingest. For hosted Cloud — not yet live —
+    # this default will be reintroduced.
+    endpoint: str | None = None
+
+    # Debug mode pretty-prints to stdout instead of shipping events.
+    # Useful during integration. Overrides api_key + output.
+    debug: bool = False
+
+    # File mode appends NDJSON events to the given path. Useful for local
+    # batch capture without a running ingest service.
+    output: str | None = None
+
+    # ── Behavior ─────────────────────────────────────────────────────────
+    environment: str = "production"
+    redact_pii: bool = True
+    capture_content: bool = True
+
+    # ── Auto-flush ───────────────────────────────────────────────────────
+    # Background thread flushes the queue this often (seconds). 5 s aligns
+    # with the TS SDK's flushIntervalMs=5000 default. The first-run UI's
+    # 3 s pre-first-call poll cadence is intentionally faster than this
+    # so the dashboard catches the first trace within ~8 s end-to-end.
+    flush_interval: float = 5.0
+    batch_size: int = 50
+    queue_max_size: int = 10_000
+    max_retries: int = 3
+
+    # ── Off-switch ───────────────────────────────────────────────────────
+    # When True, `init()` returns a no-op SDK that swallows every call.
+    # Useful in tests that import production code paths but don't want
+    # network IO. Mirrors TS `ScopeCallConfig.disabled`.
+    disabled: bool = False
+
+    # ── Defaults applied to every event ──────────────────────────────────
+    # Each of these is overridable per-trace via sdk.trace(...).
+    default_feature: str | None = None
+    default_user_id: str | None = None
+    default_session_id: str | None = None
+
+    # Round-4 review (TS): default_prompt_version tags every call with a
+    # build/commit/release identifier when the app has a single canonical
+    # prompt set. Per-trace prompt_version wins, then parent trace's
+    # value, then this default, then None.
+    default_prompt_version: str | None = None
+
+    def __post_init__(self) -> None:
+        # Serverless guard: a zero or negative interval would spin the
+        # flush thread. Clamp to 0.1 s rather than reject — the user
+        # probably meant "flush often" and we want to be forgiving.
+        if self.flush_interval <= 0:
+            self.flush_interval = 0.1
+
+    @property
+    def mode(self) -> str:
+        """Which transport `init()` should select for this config."""
+        if self.disabled:
+            return "noop"
+        if self.debug:
+            return "console"
+        if self.output:
+            return "file"
+        return "api"
+
+
+def validate(config: ScopeCallConfig) -> None:
+    """Raise ConfigError if the config can't possibly produce a working SDK.
+
+    Three valid configurations:
+      1. debug=True            → console mode (no api_key needed)
+      2. output=<path>         → file mode (no api_key needed)
+      3. api_key + endpoint    → HTTP mode (BOTH required since Round-8)
+
+    `disabled=True` shorts the entire SDK to no-ops; we don't bother
+    validating in that case because the SDK never sends anything anyway.
+    """
+    if config.disabled:
+        return
+    if config.debug:
+        return
+    if config.output:
+        return
+    if not config.api_key:
+        raise ConfigError(
+            "scopecall.init() requires one of: api_key=..., debug=True, or output=<path>."
+        )
+    # Round-8: endpoint is now required alongside api_key. No silent
+    # fallback to a hosted-Cloud URL that doesn't exist yet.
+    if not config.endpoint:
+        raise ConfigError(
+            "scopecall.init(api_key=...) requires endpoint=... "
+            "Self-hosted: point at your ingest service, e.g. "
+            "endpoint='http://localhost:8080/v1/ingest'. "
+            "(ScopeCall Cloud is not yet available; a managed default "
+            "endpoint will return in a future release.)"
+        )

scopecall/_context.py

@@ -0,0 +1,131 @@
+"""Trace context — `contextvars` propagation so nested `sdk.trace()` blocks
+chain correctly through sync code, async code, FastAPI request handlers,
+asyncio tasks, and background workers.
+
+Why `contextvars` (PEP 567) and not threadlocals: thread-locals don't
+propagate across `await` boundaries by default. `contextvars.ContextVar`
+DOES propagate across `await` and into `asyncio.create_task()`, which is
+the table-stakes property for any AI backend using `AsyncOpenAI` /
+`AsyncAnthropic`. The reviewer correctly called this out as a P0.
+
+Each `sdk.trace(name)` call:
+
+  1. Generates a new `span_id` for itself.
+  2. Reads the current `_current_trace` ContextVar (if any) to find the
+     parent's `trace_id` + `span_id`. If there is one, inherit
+     `trace_id`; otherwise mint a fresh one.
+  3. Sets the new `TraceContext` as `_current_trace` for the body of the
+     block.
+  4. Resets `_current_trace` on exit so nesting unwinds cleanly.
+
+The block ALSO emits a synthetic workflow event on exit — see
+`scopecall._sdk.ScopeCallSDK.trace` for the call site. The event is
+what the dashboard's Flow Map and trace tree render as the parent
+"workflow" node. Without it, child LLM rows would have a
+`parent_span_id` that points at nothing in ClickHouse, and the
+flow-map JOIN finds no parent.
+"""
+
+from __future__ import annotations
+
+import uuid
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TraceContext:
+    """The state a single `sdk.trace()` block carries.
+
+    The instance is what `with sdk.trace(...) as ctx:` yields — users can
+    read these fields to add custom span IDs, parent linkage etc. in
+    bespoke instrumentation.
+    """
+
+    # Stable across the whole trace tree (one trace = many spans).
+    trace_id: str
+
+    # Unique per `sdk.trace()` block. Children inside reference this as
+    # their `parent_span_id`.
+    span_id: str
+
+    # The PARENT trace's span_id, if this block is nested inside another
+    # `sdk.trace()`. None at the root.
+    parent_span_id: str | None
+
+    # The block's human label. Doubles as the default feature_name on the
+    # synthetic workflow event we emit on block exit. The reviewer's
+    # FastAPI example was `sdk.trace("chat-api", ...)` — that string ends
+    # up as feature_name='chat-api' on the workflow row.
+    name: str | None
+
+    # Per-trace prompt_version. None at this level means "inherit from
+    # config.default_prompt_version". The TS SDK does the same precedence:
+    # trace's value → parent trace's value → config default → None.
+    prompt_version: str | None = None
+
+    # Per-trace overrides for user/session/feature. None means "inherit
+    # config defaults at event-emission time."
+    user_id: str | None = None
+    session_id: str | None = None
+    feature_name: str | None = None
+
+    # Wall-clock start time (ms epoch). Used to compute the workflow
+    # span's latency when the block exits.
+    start_time_ms: float = field(default=0.0)
+
+
+# Module-level ContextVar. The reset-token pattern below is what
+# guarantees nested traces unwind in the right order even when the user
+# raises an exception inside the body.
+_current_trace: ContextVar[TraceContext | None] = ContextVar(
+    "scopecall_current_trace", default=None
+)
+
+
+def get_current() -> TraceContext | None:
+    """Return the innermost active TraceContext, or None at the root.
+
+    Provider instrumentations (chunk 2) call this to discover the parent
+    span for an outgoing LLM event. Manual API helpers (`sdk.span`,
+    `sdk.record_llm_call`) do the same.
+    """
+    return _current_trace.get()
+
+
+def push(ctx: TraceContext) -> object:
+    """Set `ctx` as the current trace and return a token.
+
+    The caller is responsible for `pop(token)` in a finally block. The
+    SDK's `trace()` context manager does this — manual callers usually
+    don't need to touch push/pop directly.
+    """
+    return _current_trace.set(ctx)
+
+
+def pop(token: object) -> None:
+    """Restore the previous TraceContext using the token from `push`.
+
+    `ContextVar.reset()` is the right primitive here because it's
+    exception-safe: reseting always succeeds even if the token's
+    var-binding was overridden by intermediate `set` calls in the
+    interim. We type the parameter as `object` because the actual
+    `Token` class isn't easily constructible in user code and exposing
+    it would invite accidental forgery.
+    """
+    _current_trace.reset(token)  # type: ignore[arg-type]
+
+
+def new_span_id() -> str:
+    """Mint a 16-hex-char span ID (matches the OTel + TS SDK convention).
+
+    OTel uses 8-byte span IDs rendered as 16 hex chars. We follow the
+    same shape so trace IDs are interoperable when an OTel bridge ships
+    in v0.2.x.
+    """
+    return uuid.uuid4().hex[:16]
+
+
+def new_trace_id() -> str:
+    """Mint a 32-hex-char trace ID (matches OTel + TS SDK convention)."""
+    return uuid.uuid4().hex

scopecall/_exporter.py

@@ -0,0 +1,273 @@
+"""Background exporter — circular buffer + auto-flush + HTTP transport.
+
+Architecturally identical to the TS SDK's
+`sdks/typescript/src/exporter.ts`:
+
+  - A bounded in-memory queue (drops oldest on overflow).
+  - A background thread that wakes up every `flush_interval` seconds (or
+    immediately on `.flush()`), drains up to `batch_size` events, and
+    posts them as one HTTP request.
+  - Auto-flush is enabled by default (Round-5 review P0 — without it,
+    long-running servers queued events forever and no traces ever
+    appeared in the dashboard).
+  - `.close()` clears the wake-up signal, drains remaining events, and
+    joins the thread within `timeout` seconds.
+
+Why a thread (not asyncio):
+  Python's `asyncio` doesn't run in non-async contexts (e.g. a sync
+  Flask request handler in a pre-3.12 app), and we have to work in both.
+  A daemon thread is the lowest-common-denominator that works for
+  sync code, async code, and background scripts. The thread holds a
+  `queue.Queue` which is itself thread-safe; the synchronisation cost
+  is negligible compared to the HTTP latency we're hiding.
+
+Why httpx (not requests):
+  httpx supports both sync and async with one API. Chunk 2's
+  AsyncOpenAI / AsyncAnthropic instrumentation lives in the same
+  process; sharing httpx means we don't ship two HTTP clients.
+"""
+
+from __future__ import annotations
+
+import atexit
+import json
+import logging
+import queue
+import threading
+import time
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+import httpx
+
+from ._version import __version__
+from .wire._event import LLMEvent
+
+if TYPE_CHECKING:
+    from ._config import ScopeCallConfig
+
+logger = logging.getLogger(__name__)
+
+
+class Exporter:
+    """Thread-safe queue + auto-flush + HTTP delivery.
+
+    One instance per SDK. `enqueue()` is what every instrumentation /
+    manual-API call hits on the hot path — must be O(1) and never block.
+    """
+
+    def __init__(self, config: ScopeCallConfig) -> None:
+        self._config = config
+        self._queue: queue.Queue[LLMEvent] = queue.Queue(maxsize=config.queue_max_size)
+        self._shutdown_event = threading.Event()
+        self._flush_now = threading.Event()
+        self._file_lock = threading.Lock()
+
+        # Concurrent flush guard — Round-5 TS review caught a race where
+        # an auto-tick and a manual `flush()` could each drain half a
+        # batch and post both halves in parallel. The lock makes flush
+        # serial; the auto-tick yields if a manual flush is in progress.
+        self._flush_lock = threading.Lock()
+
+        # HTTP client lives for the SDK's lifetime so we get TCP keepalive
+        # across batches. Headers are constant — set once.
+        self._http: httpx.Client | None = None
+        if config.mode == "api":
+            self._http = httpx.Client(
+                headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {config.api_key or ''}",
+                    "User-Agent": f"scopecall-python/{__version__}",
+                    "X-ScopeCall-SDK": "python",
+                },
+                timeout=10.0,
+            )
+
+        # Background flush thread. Daemon=True so a misbehaving thread
+        # doesn't block process exit; the atexit hook below explicitly
+        # drains before the interpreter tears down.
+        self._thread = threading.Thread(
+            target=self._run, daemon=True, name="scopecall-exporter"
+        )
+        self._thread.start()
+        # atexit-driven drain is the safety net for callers who forget
+        # to `sdk.close()`. Same role as TS's `attachProcessHooks`.
+        atexit.register(self._on_atexit)
+
+    # ── Hot path ────────────────────────────────────────────────────────
+
+    def enqueue(self, event: LLMEvent) -> None:
+        """Add an event to the export queue. Non-blocking.
+
+        On overflow we drop the OLDEST event (not the new one) — same
+        policy as the TS circular buffer. Rationale: in a sustained
+        burst the freshest events are the most useful for live debugging,
+        so we'd rather keep "what just happened" than "what happened
+        first" when the queue saturates.
+        """
+        if self._config.mode == "noop":
+            return
+        try:
+            self._queue.put_nowait(event)
+        except queue.Full:
+            # Drop oldest, retry. Two-stage so the get + put are both
+            # non-blocking; if another thread drains between them we
+            # might still fail to enqueue — that's acceptable degraded
+            # behavior under heavy backpressure.
+            try:
+                self._queue.get_nowait()
+                self._queue.put_nowait(event)
+            except (queue.Empty, queue.Full):
+                pass
+
+    # ── User-facing controls ────────────────────────────────────────────
+
+    def flush(self, timeout: float = 5.0) -> None:
+        """Drain the queue synchronously, blocking up to `timeout` seconds.
+
+        Returns when either:
+          - every queued event has been posted (or written to file /
+            console), OR
+          - `timeout` elapses, whichever comes first.
+
+        Safe to call concurrently with auto-flush ticks — the lock
+        serialises them.
+        """
+        self._flush_now.set()
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            # unfinished_tasks counts items dequeued but not `task_done()`d —
+            # essentially "events that started flushing but haven't
+            # finished." When the queue is empty AND no flush is in
+            # flight, we're truly drained.
+            if self._queue.unfinished_tasks == 0:
+                return
+            time.sleep(0.02)
+
+    def close(self, timeout: float = 5.0) -> None:
+        """Shut the SDK down: stop the auto-flush thread, drain remaining
+        events, close the HTTP client.
+
+        Idempotent — calling twice is a no-op.
+        """
+        if self._shutdown_event.is_set():
+            return
+        self._shutdown_event.set()
+        # Wake the flush thread so it sees the shutdown signal without
+        # waiting out its current sleep interval.
+        self._flush_now.set()
+        self._thread.join(timeout=timeout)
+        if self._http is not None:
+            self._http.close()
+            self._http = None
+
+    # ── Internals ───────────────────────────────────────────────────────
+
+    def _on_atexit(self) -> None:
+        # atexit is best-effort — if the process is dying from SIGKILL
+        # we never get here. For graceful exits this gives us one last
+        # chance to ship the queue.
+        try:
+            self.close(timeout=2.0)
+        except Exception:  # noqa: BLE001
+            pass
+
+    def _run(self) -> None:
+        """Auto-flush loop. Wakes on either a periodic tick or an explicit
+        `flush_now` signal."""
+        while not self._shutdown_event.is_set():
+            self._flush_now.wait(timeout=self._config.flush_interval)
+            self._flush_now.clear()
+            self._drain()
+        # Final drain on shutdown — the wait loop above might exit without
+        # draining the queue if `_shutdown_event` was set first.
+        self._drain()
+
+    def _drain(self) -> None:
+        """Pop up to batch_size events, ship them, mark task_done.
+
+        Held under `_flush_lock` so a manual flush() can't double-drain
+        while the auto-tick is mid-flight.
+        """
+        with self._flush_lock:
+            batch: list[LLMEvent] = []
+            while len(batch) < self._config.batch_size:
+                try:
+                    batch.append(self._queue.get_nowait())
+                except queue.Empty:
+                    break
+            if not batch:
+                return
+
+            try:
+                self._send_batch(batch)
+            except Exception as exc:  # noqa: BLE001
+                # The SDK must NEVER raise into customer code. A failed
+                # batch is logged at debug — operators who want louder
+                # logging can crank `logging.getLogger("scopecall")` up.
+                logger.debug("scopecall: export failed: %s", exc)
+            finally:
+                for _ in batch:
+                    self._queue.task_done()
+
+    def _send_batch(self, batch: list[LLMEvent]) -> None:
+        """Ship one batch via the configured transport (console/file/API).
+
+        The HTTP envelope matches the Rust ingest contract documented in
+        `services-rust/ingest/src/routes/ingest.rs`:
+
+            { "events": [ <LLMEvent.to_wire()>, ... ],
+              "sent_at": "<RFC3339 timestamp>" }
+
+        The Rust side rejects payloads without `sent_at` to catch clock
+        skew / stale-deliveries (Round-1 review P0).
+        """
+        mode = self._config.mode
+
+        if mode == "console":
+            for ev in batch:
+                print(json.dumps(ev.to_wire(), indent=2, default=str))
+            return
+
+        if mode == "file":
+            assert self._config.output is not None
+            with self._file_lock, open(self._config.output, "a") as f:
+                for ev in batch:
+                    f.write(json.dumps(ev.to_wire(), default=str) + "\n")
+            return
+
+        # API mode. Retries with exponential backoff; on final failure
+        # the events are silently dropped (logged at debug). The Rust
+        # ingest is durable past this point — once a 2xx returns, the
+        # event is committed to Redpanda before the HTTP response is
+        # sent, so we don't have to worry about partial acceptance.
+        assert self._http is not None
+        assert self._config.endpoint is not None
+        envelope = {
+            "events": [ev.to_wire() for ev in batch],
+            "sent_at": datetime.now(timezone.utc).isoformat(),
+        }
+        backoff = 0.1
+        for attempt in range(self._config.max_retries):
+            if self._shutdown_event.is_set() and attempt > 0:
+                # Don't keep retrying past shutdown — better to drop
+                # than to delay process exit.
+                return
+            try:
+                resp = self._http.post(self._config.endpoint, json=envelope)
+                resp.raise_for_status()
+                return
+            except httpx.HTTPError as exc:
+                if attempt < self._config.max_retries - 1:
+                    # Use the shutdown event as the sleep — wakes early
+                    # on close() so we don't waste backoff time during
+                    # graceful shutdown.
+                    self._shutdown_event.wait(timeout=backoff)
+                    backoff *= 2
+                else:
+                    logger.debug(
+                        "scopecall: dropping %d events after %d retries: %s",
+                        len(batch),
+                        self._config.max_retries,
+                        exc,
+                    )

scopecall/_pricing.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import datetime
+import logging
+import threading
+from dataclasses import dataclass
+
+logger = logging.getLogger(__name__)
+
+# Update LAST_VERIFIED_DATE when refreshing this table.
+# CI (test_pricing_freshness.py) fails if it's older than 90 days.
+LAST_VERIFIED_DATE = datetime.date(2026, 5, 22)
+
+# (input_cost_per_1k, output_cost_per_1k) in USD
+_BUNDLED: dict[str, tuple[float, float]] = {
+    # OpenAI
+    "gpt-4o": (0.0025, 0.010),
+    "gpt-4o-mini": (0.00015, 0.00060),
+    "gpt-4-turbo": (0.010, 0.030),
+    "gpt-4-turbo-preview": (0.010, 0.030),
+    "gpt-4": (0.030, 0.060),
+    "gpt-3.5-turbo": (0.0005, 0.0015),
+    "gpt-3.5-turbo-0125": (0.0005, 0.0015),
+    # Anthropic
+    "claude-opus-4-7": (0.015, 0.075),
+    "claude-sonnet-4-6": (0.003, 0.015),
+    "claude-haiku-4-5-20251001": (0.00025, 0.00125),
+    "claude-3-5-sonnet-20241022": (0.003, 0.015),
+    "claude-3-5-haiku-20241022": (0.00025, 0.00125),
+    "claude-3-opus-20240229": (0.015, 0.075),
+    "claude-3-sonnet-20240229": (0.003, 0.015),
+    "claude-3-haiku-20240307": (0.00025, 0.00125),
+    # Google
+    "gemini-1.5-pro": (0.00125, 0.005),
+    "gemini-1.5-flash": (0.000075, 0.0003),
+    "gemini-2.0-flash": (0.0001, 0.0004),
+}
+
+
+@dataclass
+class PricingTable:
+    _table: dict[str, tuple[float, float]]
+    _lock: threading.Lock
+
+    def __init__(self) -> None:
+        self._table = dict(_BUNDLED)
+        self._lock = threading.Lock()
+
+    def calculate(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        with self._lock:
+            entry = self._table.get(model)
+        if entry is None:
+            # Try prefix match for versioned model names (e.g. "gpt-4o-2024-11-20")
+            with self._lock:
+                for key, val in self._table.items():
+                    if model.startswith(key):
+                        entry = val
+                        break
+        if entry is None:
+            return 0.0
+        input_cost, output_cost = entry
+        return round(
+            (input_tokens / 1000 * input_cost) + (output_tokens / 1000 * output_cost),
+            6,
+        )
+
+    def update(self, model: str, input_per_1k: float, output_per_1k: float) -> None:
+        with self._lock:
+            self._table[model] = (input_per_1k, output_per_1k)