metergraph 0.6.0__tar.gz → 0.6.2__tar.gz

{metergraph-0.6.0 → metergraph-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metergraph
-Version: 0.6.0
+Version: 0.6.2
 Summary: Fire-and-forget LLM spend capture for Metergraph
 Author: Pioneer Square Labs
 License-Expression: Apache-2.0
@@ -13,12 +13,15 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Provides-Extra: otel
+Requires-Dist: opentelemetry-sdk>=1.30; extra == "otel"
 Provides-Extra: dev
 Requires-Dist: build>=1; extra == "dev"
 Requires-Dist: pytest>=8; extra == "dev"
-Requires-Dist: openai>=2.50.0; extra == "dev"
-Requires-Dist: anthropic>=0.40; extra == "dev"
+Requires-Dist: openai<3,>=2.50.0; extra == "dev"
+Requires-Dist: anthropic<1,>=0.40; extra == "dev"
 Requires-Dist: google-genai>=1; extra == "dev"
+Requires-Dist: opentelemetry-sdk>=1.30; extra == "dev"
 
 # metergraph (Python)
 
@@ -38,12 +41,15 @@ from openai import OpenAI
 metergraph.init(repository="owner/repository")
 # Anthropic() and google-genai's genai.Client() wrap the same way.
 client = metergraph.wrap(OpenAI())
-metergraph.set_session("ticket-123")
 
-with metergraph.trace("ticket-workflow"):
-    with metergraph.route("ticket-classifier", unit="answer"):
-        model = metergraph.model_for("ticket-classifier", default="gpt-4.1-mini")
-        client.chat.completions.create(model=model, messages=[...])
+with metergraph.context(
+    session_id="ticket-123",
+    tags={"customer": "acme"},
+):
+    with metergraph.trace("ticket-workflow"):
+        with metergraph.route("ticket-classifier", unit="answer"):
+            model = metergraph.model_for("ticket-classifier", default="gpt-4.1-mini")
+            client.chat.completions.create(model=model, messages=[...])
 
 # Emit this after the user-visible task resolves. It shares the bounded async
 # transport and contains no prompt or output content.
@@ -57,6 +63,14 @@ metergraph.record_outcome(
 )
 ```
 
+Use `metergraph.context()` for request or job identity. It follows async work
+created inside the scope and is restored afterward, so concurrent and reused
+workers cannot leak session IDs or tags into one another. The narrower
+`metergraph.session()` and `metergraph.tags()` scopes compose with it.
+`metergraph.set_default_tags()` sets process-wide service metadata. Legacy
+`set_session()` and `set_tags()` calls only update an active Metergraph scope;
+outside one they warn once and do nothing.
+
 Vercel's supported Python surface is AI Gateway through the OpenAI or
 Anthropic SDK. Point either client at the public gateway and `wrap()` detects
 it automatically:
@@ -83,12 +97,44 @@ async, streaming, tool calls, and OpenAI Responses API calls are captured. Use
 `metergraph.wrap(client, provider="vercel")` only when a compatible client is
 behind a custom gateway URL that cannot be detected automatically.
 
+## OpenTelemetry GenAI export
+
+`MetergraphGenAIExporter` is a standard OpenTelemetry span exporter for GenAI
+semantic-convention spans. The currently qualified integration is LiteLLM:
+install the optional integration and configure MeterGraph as LiteLLM's custom
+exporter. Existing LiteLLM call sites remain unchanged and must not also be
+wrapped.
+
+```bash
+python -m pip install 'metergraph[otel]' 'litellm[proxy]>=1.96.2,<2'
+```
+
+```python
+import litellm
+from litellm.integrations.opentelemetry import OpenTelemetry, OpenTelemetryConfig
+from metergraph.opentelemetry import MetergraphGenAIExporter
+
+litellm.callbacks.append(OpenTelemetry(OpenTelemetryConfig(
+    exporter=MetergraphGenAIExporter(),
+    capture_message_content="SPAN_ONLY",
+)))
+```
+
+The exporter preserves OpenTelemetry trace identity, model/provider metadata,
+token usage, latency, system instructions, ordered messages, and text output.
+Message content is explicitly enabled because it may be sensitive. Text parts
+are retained and replayable in the current POC pipeline. Calls containing other
+part types retain their model, usage, timing, and status metadata, but those
+parts are not replayable yet. See the runnable
+[`python-litellm-otel` example](../examples/python-litellm-otel/).
+
 Configuration:
 
 - `METERGRAPH_APP_TOKEN` — required bearer token
 - `METERGRAPH_INGEST_URL` — optional override; defaults to the hosted HTTPS endpoint
 - `METERGRAPH_REPOSITORY` — optional `owner/repository` identity; used by [MeterGraph Bot](https://github.com/apps/metergraph)
 - `METERGRAPH_CAPTURE_TEXT=0` — opt out of content capture globally
+- `METERGRAPH_TEXT_MAX_BYTES` — per-field content limit; defaults to 1 MiB
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
@@ -110,11 +156,13 @@ identity, it warns once and continues capture without repository attribution.
 
 Delivery is bounded and off the request path. Queue overflow or a collector
 outage drops capture and increments internal counters; it never changes the
-provider call. Each wire batch is bounded to 512 KiB after optional gzip.
+provider call. Each wire batch is bounded to 4 MiB after optional gzip.
 By default, Metergraph captures the scrubbed provider request and a normalized
 response envelope, including assistant content and tool calls. Provider
 credentials and transport headers are removed. Request and response are each
-limited to 100 KiB of UTF-8 with an explicit truncation marker.
+limited to 1 MiB of UTF-8 by default with an explicit truncation marker. Set
+`METERGRAPH_TEXT_MAX_BYTES` or initialize with `text_max_bytes=...` to raise
+the per-field limit for larger prompts and responses.
 `capture_text=False` on `route()` or `trace()` overrides the global content
 policy for a sensitive operation. The equivalent initialization option is
 `metergraph.init(capture_text=False)`. The public open-source server continues

metergraph-0.6.0/src/metergraph.egg-info/PKG-INFO → metergraph-0.6.2/README.md

@@ -1,25 +1,3 @@
-Metadata-Version: 2.4
-Name: metergraph
-Version: 0.6.0
-Summary: Fire-and-forget LLM spend capture for Metergraph
-Author: Pioneer Square Labs
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://www.metergraph.dev/
-Project-URL: Repository, https://github.com/PioneerSquareLabs/metergraphsdk
-Project-URL: Issues, https://github.com/PioneerSquareLabs/metergraphsdk/issues
-Keywords: llm,observability,openai,anthropic,gemini,vercel-ai-gateway,cost-tracking
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Typing :: Typed
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Requires-Dist: build>=1; extra == "dev"
-Requires-Dist: pytest>=8; extra == "dev"
-Requires-Dist: openai>=2.50.0; extra == "dev"
-Requires-Dist: anthropic>=0.40; extra == "dev"
-Requires-Dist: google-genai>=1; extra == "dev"
-
 # metergraph (Python)
 
 Zero-runtime-dependency capture for OpenAI, Anthropic, Gemini, and Python
@@ -38,12 +16,15 @@ from openai import OpenAI
 metergraph.init(repository="owner/repository")
 # Anthropic() and google-genai's genai.Client() wrap the same way.
 client = metergraph.wrap(OpenAI())
-metergraph.set_session("ticket-123")
 
-with metergraph.trace("ticket-workflow"):
-    with metergraph.route("ticket-classifier", unit="answer"):
-        model = metergraph.model_for("ticket-classifier", default="gpt-4.1-mini")
-        client.chat.completions.create(model=model, messages=[...])
+with metergraph.context(
+    session_id="ticket-123",
+    tags={"customer": "acme"},
+):
+    with metergraph.trace("ticket-workflow"):
+        with metergraph.route("ticket-classifier", unit="answer"):
+            model = metergraph.model_for("ticket-classifier", default="gpt-4.1-mini")
+            client.chat.completions.create(model=model, messages=[...])
 
 # Emit this after the user-visible task resolves. It shares the bounded async
 # transport and contains no prompt or output content.
@@ -57,6 +38,14 @@ metergraph.record_outcome(
 )
 ```
 
+Use `metergraph.context()` for request or job identity. It follows async work
+created inside the scope and is restored afterward, so concurrent and reused
+workers cannot leak session IDs or tags into one another. The narrower
+`metergraph.session()` and `metergraph.tags()` scopes compose with it.
+`metergraph.set_default_tags()` sets process-wide service metadata. Legacy
+`set_session()` and `set_tags()` calls only update an active Metergraph scope;
+outside one they warn once and do nothing.
+
 Vercel's supported Python surface is AI Gateway through the OpenAI or
 Anthropic SDK. Point either client at the public gateway and `wrap()` detects
 it automatically:
@@ -83,12 +72,44 @@ async, streaming, tool calls, and OpenAI Responses API calls are captured. Use
 `metergraph.wrap(client, provider="vercel")` only when a compatible client is
 behind a custom gateway URL that cannot be detected automatically.
 
+## OpenTelemetry GenAI export
+
+`MetergraphGenAIExporter` is a standard OpenTelemetry span exporter for GenAI
+semantic-convention spans. The currently qualified integration is LiteLLM:
+install the optional integration and configure MeterGraph as LiteLLM's custom
+exporter. Existing LiteLLM call sites remain unchanged and must not also be
+wrapped.
+
+```bash
+python -m pip install 'metergraph[otel]' 'litellm[proxy]>=1.96.2,<2'
+```
+
+```python
+import litellm
+from litellm.integrations.opentelemetry import OpenTelemetry, OpenTelemetryConfig
+from metergraph.opentelemetry import MetergraphGenAIExporter
+
+litellm.callbacks.append(OpenTelemetry(OpenTelemetryConfig(
+    exporter=MetergraphGenAIExporter(),
+    capture_message_content="SPAN_ONLY",
+)))
+```
+
+The exporter preserves OpenTelemetry trace identity, model/provider metadata,
+token usage, latency, system instructions, ordered messages, and text output.
+Message content is explicitly enabled because it may be sensitive. Text parts
+are retained and replayable in the current POC pipeline. Calls containing other
+part types retain their model, usage, timing, and status metadata, but those
+parts are not replayable yet. See the runnable
+[`python-litellm-otel` example](../examples/python-litellm-otel/).
+
 Configuration:
 
 - `METERGRAPH_APP_TOKEN` — required bearer token
 - `METERGRAPH_INGEST_URL` — optional override; defaults to the hosted HTTPS endpoint
 - `METERGRAPH_REPOSITORY` — optional `owner/repository` identity; used by [MeterGraph Bot](https://github.com/apps/metergraph)
 - `METERGRAPH_CAPTURE_TEXT=0` — opt out of content capture globally
+- `METERGRAPH_TEXT_MAX_BYTES` — per-field content limit; defaults to 1 MiB
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
@@ -110,11 +131,13 @@ identity, it warns once and continues capture without repository attribution.
 
 Delivery is bounded and off the request path. Queue overflow or a collector
 outage drops capture and increments internal counters; it never changes the
-provider call. Each wire batch is bounded to 512 KiB after optional gzip.
+provider call. Each wire batch is bounded to 4 MiB after optional gzip.
 By default, Metergraph captures the scrubbed provider request and a normalized
 response envelope, including assistant content and tool calls. Provider
 credentials and transport headers are removed. Request and response are each
-limited to 100 KiB of UTF-8 with an explicit truncation marker.
+limited to 1 MiB of UTF-8 by default with an explicit truncation marker. Set
+`METERGRAPH_TEXT_MAX_BYTES` or initialize with `text_max_bytes=...` to raise
+the per-field limit for larger prompts and responses.
 `capture_text=False` on `route()` or `trace()` overrides the global content
 policy for a sensitive operation. The equivalent initialization option is
 `metergraph.init(capture_text=False)`. The public open-source server continues

{metergraph-0.6.0 → metergraph-0.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metergraph"
-version = "0.6.0"
+version = "0.6.2"
 description = "Fire-and-forget LLM spend capture for Metergraph"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,7 +20,8 @@ Repository = "https://github.com/PioneerSquareLabs/metergraphsdk"
 Issues = "https://github.com/PioneerSquareLabs/metergraphsdk/issues"
 
 [project.optional-dependencies]
-dev = ["build>=1", "pytest>=8", "openai>=2.50.0", "anthropic>=0.40", "google-genai>=1"]
+otel = ["opentelemetry-sdk>=1.30"]
+dev = ["build>=1", "pytest>=8", "openai>=2.50.0,<3", "anthropic>=0.40,<1", "google-genai>=1", "opentelemetry-sdk>=1.30"]
 
 [build-system]
 requires = ["setuptools>=68"]

{metergraph-0.6.0 → metergraph-0.6.2}/src/metergraph/__init__.py

@@ -10,10 +10,21 @@ import uuid
 from datetime import datetime, timezone
 from typing import Any, Callable
 
-from ._capture import Options, Runtime, set_runtime
+from ._capture import DEFAULT_TEXT_MAX_BYTES, Options, Runtime, set_runtime
 from ._capture import wrap as _wrap
 from ._config import ConfigPoller
-from ._context import route, set_session, set_tags, snapshot, trace, wrap_executor
+from ._context import (
+    context,
+    route,
+    session,
+    set_default_tags,
+    set_session,
+    set_tags,
+    snapshot,
+    tags,
+    trace,
+    wrap_executor,
+)
 from ._batch_first import (
     BatchFirstIneligibleError,
     BatchFirstMetadata,
@@ -69,6 +80,7 @@ def init(
     skip_frames: list[str] | None = None,
     environment: str | None = None,
     disabled: bool | None = None,
+    text_max_bytes: int | None = None,
 ) -> None:
     """Initialize capture. This function is idempotent and never raises."""
     global _initialized, _warned_no_token, _warned_no_repository
@@ -136,15 +148,14 @@ def init(
             repo_root=repo_config.repo_root if repo_config is not None else None,
             skip_frames=tuple(skip_frames or ()),
             environment=environment or os.getenv("METERGRAPH_ENV"),
-            text_max_bytes=min(
-                100 * 1024,
-                max(
-                    1,
-                    int(
-                        os.getenv(
-                            "METERGRAPH_TEXT_MAX_BYTES", str(100 * 1024)
-                        )
-                    ),
+            text_max_bytes=max(
+                1,
+                int(
+                    text_max_bytes
+                    if text_max_bytes is not None
+                    else os.getenv(
+                        "METERGRAPH_TEXT_MAX_BYTES", str(DEFAULT_TEXT_MAX_BYTES)
+                    )
                 ),
             ),
         )
@@ -290,14 +301,18 @@ __all__ = [
     "BatchFirstResult",
     "LateBatchInfo",
     "batch_first",
+    "context",
     "flush",
     "init",
     "model_for",
     "record_outcome",
     "route",
+    "session",
+    "set_default_tags",
     "set_session",
     "set_tags",
     "shutdown",
+    "tags",
     "track",
     "trace",
     "wrap",

{metergraph-0.6.0 → metergraph-0.6.2}/src/metergraph/_capture.py

@@ -24,6 +24,7 @@ from ._version import SDK_VERSION
 
 
 log = logging.getLogger("metergraph")
+DEFAULT_TEXT_MAX_BYTES = 1024 * 1024
 
 
 def _get(value: Any, name: str, default: Any = None) -> Any:
@@ -254,6 +255,48 @@ def _stop_reason(response: Any) -> str | None:
     return str(reason) if reason is not None else None
 
 
+def _normalize_finish_reason(value: str) -> str:
+    normalized = "-".join(value.strip().lower().replace("_", "-").split())
+    if normalized in {"stop", "end-turn", "stop-sequence", "completed", "succeeded"}:
+        return "stop"
+    if normalized in {"length", "max-tokens", "max-output-tokens"}:
+        return "length"
+    if normalized in {"content-filter", "safety", "blocked"}:
+        return "content-filter"
+    if normalized in {"tool-calls", "tool-use", "function-call"}:
+        return "tool-calls"
+    if normalized in {"error", "failed"}:
+        return "error"
+    if normalized in {"other", "unknown"}:
+        return "other"
+    return normalized
+
+
+def _finish_reason_details(response: Any) -> tuple[str | None, str | None]:
+    response_status = _get(response, "status")
+    incomplete_reason = (
+        _get(_get(response, "incomplete_details"), "reason")
+        if response_status == "incomplete"
+        else None
+    )
+    value = (
+        _get(response, "stop_reason")
+        or incomplete_reason
+        or response_status
+        or _get(response, "finishReason")
+        or _get(response, "finish_reason")
+        or _get(_first(_get(response, "choices")), "finish_reason")
+    )
+    unified = _get(value, "unified")
+    raw_value = _get(value, "raw") or (value if unified is None else None)
+    source = unified if unified is not None else raw_value
+    if source is None:
+        return None, None
+    finish_reason = _normalize_finish_reason(str(source))
+    raw = str(raw_value) if raw_value is not None else None
+    return finish_reason, raw if raw != finish_reason else None
+
+
 def _request_id(response: Any) -> str | None:
     value = (
         _get(response, "_request_id")
@@ -597,7 +640,7 @@ class Options:
     repo_root: str | None = None
     skip_frames: tuple[str, ...] = ()
     environment: str | None = None
-    text_max_bytes: int = 100 * 1024
+    text_max_bytes: int = DEFAULT_TEXT_MAX_BYTES
 
 
 class Runtime:
@@ -740,6 +783,12 @@ class CallState:
         effective_status = status or (
             "error" if error else _stop_reason(response) or "success"
         )
+        finish_reason, finish_reason_raw = _finish_reason_details(response)
+        status_code = (
+            "error"
+            if error or status == "error" or finish_reason == "error"
+            else "unset"
+        )
         response_json, response_truncated = self.runtime._text(
             json.dumps(
                 _response_envelope(
@@ -764,6 +813,9 @@ class CallState:
             **_usage(response),
             "latency_ms": round((time.perf_counter() - self.started) * 1000),
             "status": effective_status,
+            "status_code": status_code,
+            "finish_reason": finish_reason,
+            "finish_reason_raw": finish_reason_raw,
             "session_id": self.context.session_id,
             "conversation_id": self.context.session_id,
             "trace_id": self.trace_id,
@@ -792,7 +844,7 @@ class CallState:
             "frames_json": self.frames,
             "tags": dict(self.context.tags),
             "environment": self.runtime.options.environment,
-            "error": bool(error),
+            "error": status_code == "error",
             "error_type": type(error).__name__ if error else None,
             "sdk": "python",
             "sdk_version": SDK_VERSION,
@@ -1004,6 +1056,11 @@ def set_runtime(runtime: Runtime | None) -> None:
     _runtime = runtime
 
 
+def _get_runtime() -> Runtime | None:
+    """Return the active runtime to internal capture integrations."""
+    return _runtime
+
+
 def _request(args: tuple, kwargs: dict) -> dict[str, Any]:
     request: dict[str, Any] = {}
     if args and isinstance(args[0], Mapping):

{metergraph-0.6.0 → metergraph-0.6.2}/src/metergraph/_context.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import contextvars
 import functools
 import inspect
+import logging
 import secrets
 from concurrent.futures import Executor
 from dataclasses import dataclass, field, replace
@@ -29,10 +30,97 @@ class CaptureContext:
 _current: contextvars.ContextVar[CaptureContext] = contextvars.ContextVar(
     "metergraph_context", default=CaptureContext()
 )
+_active_depth: contextvars.ContextVar[int] = contextvars.ContextVar(
+    "metergraph_context_depth", default=0
+)
+_default_tags: dict[str, str] = {}
+_warned_session_outside_scope = False
+_warned_tags_outside_scope = False
+log = logging.getLogger("metergraph")
 
 
 def snapshot() -> CaptureContext:
-    return _current.get()
+    current = _current.get()
+    if _active_depth.get() == 0 and _default_tags:
+        return replace(current, tags={**_default_tags, **current.tags})
+    return current
+
+
+def _enter_scope(value: CaptureContext):
+    return _current.set(value), _active_depth.set(_active_depth.get() + 1)
+
+
+def _exit_scope(tokens) -> None:
+    current_token, depth_token = tokens
+    _current.reset(current_token)
+    _active_depth.reset(depth_token)
+
+
+class context:
+    """Scoped session and tag context manager and sync/async decorator."""
+
+    def __init__(
+        self,
+        *,
+        session_id: str | None = None,
+        tags: Mapping[str, Any] | None = None,
+    ) -> None:
+        self.session_id = str(session_id) if session_id is not None else None
+        self.tags = {str(k): str(v) for k, v in (tags or {}).items()}
+        self._tokens = None
+
+    def __enter__(self) -> "context":
+        current = snapshot()
+        self._tokens = _enter_scope(
+            replace(
+                current,
+                session_id=(
+                    self.session_id
+                    if self.session_id is not None
+                    else current.session_id
+                ),
+                tags={**current.tags, **self.tags},
+            )
+        )
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        if self._tokens is not None:
+            _exit_scope(self._tokens)
+            self._tokens = None
+
+    def __call__(self, fn: Callable):
+        if inspect.iscoroutinefunction(fn):
+
+            @functools.wraps(fn)
+            async def async_wrapped(*args, **kwargs):
+                with type(self)(session_id=self.session_id, tags=self.tags):
+                    return await fn(*args, **kwargs)
+
+            return async_wrapped
+
+        @functools.wraps(fn)
+        def wrapped(*args, **kwargs):
+            with type(self)(session_id=self.session_id, tags=self.tags):
+                return fn(*args, **kwargs)
+
+        return wrapped
+
+
+def session(session_id: str | None) -> context:
+    """Return a scope that overrides the current session ID."""
+    return context(session_id=session_id)
+
+
+def tags(**values: Any) -> context:
+    """Return a scope that merges tags into the current context."""
+    return context(tags=values)
+
+
+def set_default_tags(**values: Any) -> None:
+    """Replace process-wide tags inherited by new Metergraph scopes."""
+    global _default_tags
+    _default_tags = {str(k): str(v) for k, v in values.items()}
 
 
 class route:
@@ -56,12 +144,12 @@ class route:
         self.capture_text = (
             bool(capture_text) if capture_text is not None else None
         )
-        self._token: contextvars.Token[CaptureContext] | None = None
+        self._tokens = None
 
     def __enter__(self) -> "route":
         current = snapshot()
         merged = {**current.tags, **self.tags}
-        self._token = _current.set(
+        self._tokens = _enter_scope(
             replace(
                 current,
                 route=self.name,
@@ -78,9 +166,9 @@ class route:
         return self
 
     def __exit__(self, exc_type, exc, tb) -> None:
-        if self._token is not None:
-            _current.reset(self._token)
-            self._token = None
+        if self._tokens is not None:
+            _exit_scope(self._tokens)
+            self._tokens = None
 
     def __call__(self, fn: Callable):
         if inspect.iscoroutinefunction(fn):
@@ -131,7 +219,7 @@ class trace:
         self.capture_text = (
             bool(capture_text) if capture_text is not None else None
         )
-        self._token: contextvars.Token[CaptureContext] | None = None
+        self._tokens = None
 
     def __enter__(self) -> "trace":
         current = snapshot()
@@ -139,7 +227,7 @@ class trace:
         reuse = current.trace_id is not None and (
             requested is None or requested == current.trace_id
         )
-        self._token = _current.set(
+        self._tokens = _enter_scope(
             replace(
                 current,
                 trace_id=(
@@ -165,9 +253,9 @@ class trace:
         return self
 
     def __exit__(self, exc_type, exc, tb) -> None:
-        if self._token is not None:
-            _current.reset(self._token)
-            self._token = None
+        if self._tokens is not None:
+            _exit_scope(self._tokens)
+            self._tokens = None
 
     def __call__(self, fn: Callable):
         if inspect.iscoroutinefunction(fn):
@@ -198,12 +286,30 @@ class trace:
 
 
 def set_session(session_id: str | None) -> None:
+    global _warned_session_outside_scope
+    if _active_depth.get() == 0:
+        if not _warned_session_outside_scope:
+            _warned_session_outside_scope = True
+            log.warning(
+                "metergraph.set_session() requires an active Metergraph context; "
+                "use metergraph.context() or metergraph.session()."
+            )
+        return
     _current.set(
         replace(snapshot(), session_id=str(session_id) if session_id else None)
     )
 
 
 def set_tags(**tags: Any) -> None:
+    global _warned_tags_outside_scope
+    if _active_depth.get() == 0:
+        if not _warned_tags_outside_scope:
+            _warned_tags_outside_scope = True
+            log.warning(
+                "metergraph.set_tags() requires an active Metergraph context; "
+                "use metergraph.context() or metergraph.tags()."
+            )
+        return
     current = snapshot()
     merged = {**current.tags, **{str(k): str(v) for k, v in tags.items()}}
     _current.set(replace(current, tags=merged))

metergraph-0.6.2/src/metergraph/_repo_config.py

@@ -0,0 +1,63 @@
+"""Read-only discovery of repository identity configuration."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from dataclasses import dataclass
+
+
+log = logging.getLogger("metergraph")
+CONFIG_DIRNAME = ".metergraph"
+CONFIG_FILENAME = "config.json"
+SUPPORTED_CONFIG_VERSION = 2
+_MAX_WALK_UP = 64
+
+
+@dataclass(frozen=True)
+class RepoConfig:
+    repository: str
+    repo_root: str
+
+
+def discover_repo_config(app_root: str) -> RepoConfig | None:
+    """Walk upward from app_root looking for .metergraph/config.json."""
+    current = os.path.realpath(app_root)
+    for _ in range(_MAX_WALK_UP):
+        candidate = os.path.join(current, CONFIG_DIRNAME, CONFIG_FILENAME)
+        if os.path.isfile(candidate):
+            return _load(candidate, current)
+        parent = os.path.dirname(current)
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+def _load(path: str, repo_root: str) -> RepoConfig | None:
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            doc = json.load(handle)
+    except (OSError, json.JSONDecodeError) as exc:
+        log.warning("metergraph: found %s but could not read it: %s", path, exc)
+        return None
+    if (
+        not isinstance(doc, dict)
+        or doc.get("version", SUPPORTED_CONFIG_VERSION)
+        != SUPPORTED_CONFIG_VERSION
+    ):
+        log.warning(
+            "metergraph: %s has an unsupported schema version; ignoring "
+            "(expected version %d)",
+            path,
+            SUPPORTED_CONFIG_VERSION,
+        )
+        return None
+    repository = doc.get("repository")
+    if not isinstance(repository, str) or "/" not in repository:
+        log.warning(
+            "metergraph: %s is missing a valid 'repository' field; ignoring", path
+        )
+        return None
+    return RepoConfig(repository=repository, repo_root=repo_root)

{metergraph-0.6.0 → metergraph-0.6.2}/src/metergraph/_transport.py

@@ -18,7 +18,7 @@ from ._version import SDK_VERSION
 
 
 log = logging.getLogger("metergraph")
-MAX_BATCH_BYTES = 512 * 1024
+MAX_BATCH_BYTES = 4 * 1024 * 1024
 
 
 class Writer:

{metergraph-0.6.0 → metergraph-0.6.2}/src/metergraph/_version.py

@@ -8,4 +8,4 @@ import importlib.metadata
 try:
     SDK_VERSION = importlib.metadata.version("metergraph")
 except Exception:
-    SDK_VERSION = "0.6.0"
+    SDK_VERSION = "0.6.2"

metergraph-0.6.2/src/metergraph/opentelemetry.py

@@ -0,0 +1,221 @@
+"""OpenTelemetry GenAI span export through MeterGraph's existing transport."""
+
+from __future__ import annotations
+
+import json
+import time
+from datetime import datetime, timezone
+from typing import Any, Mapping, Sequence
+
+import metergraph
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.trace import StatusCode
+
+from ._capture import _get_runtime
+from ._context import CaptureContext
+
+
+class OpenTelemetrySpanError(Exception):
+    """Internal marker used to preserve an exported span's error status."""
+
+
+def _attribute(attributes: Mapping[str, Any], name: str) -> Any:
+    return attributes.get(name)
+
+
+def _first_string(value: Any) -> str | None:
+    if isinstance(value, str):
+        try:
+            decoded = json.loads(value)
+        except (TypeError, ValueError, json.JSONDecodeError):
+            decoded = None
+        if isinstance(decoded, list) and decoded:
+            return str(decoded[0])
+        return value
+    if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
+        return str(value[0]) if value else None
+    return None
+
+
+def _text_from_output_messages(value: Any) -> str | None:
+    if not isinstance(value, str):
+        return None
+    try:
+        messages = json.loads(value)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return None
+    if not isinstance(messages, list):
+        return None
+    for message in messages:
+        if not isinstance(message, Mapping):
+            continue
+        parts = message.get("parts")
+        if not isinstance(parts, list):
+            continue
+        texts: list[str] = []
+        for part in parts:
+            if (
+                isinstance(part, Mapping)
+                and part.get("type") == "text"
+                and isinstance(part.get("content"), str)
+            ):
+                texts.append(part["content"])
+        if texts:
+            return "".join(texts)
+    return None
+
+
+def _request_content(attributes: Mapping[str, Any]) -> tuple[str | None, str | None]:
+    system = _attribute(attributes, "gen_ai.system_instructions")
+    messages = _attribute(attributes, "gen_ai.input.messages")
+    if not isinstance(messages, str):
+        return system if isinstance(system, str) else None, None
+    if isinstance(system, str):
+        return system, messages
+    try:
+        decoded = json.loads(messages)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return None, messages
+    if not isinstance(decoded, list):
+        return None, messages
+
+    system_parts: list[Any] = []
+    conversation: list[Any] = []
+    for message in decoded:
+        if isinstance(message, Mapping) and message.get("role") == "system":
+            parts = message.get("parts")
+            if isinstance(parts, list):
+                system_parts.extend(parts)
+            continue
+        conversation.append(message)
+    if not system_parts:
+        return None, messages
+    return (
+        json.dumps(system_parts, separators=(",", ":"), ensure_ascii=False),
+        json.dumps(conversation, separators=(",", ":"), ensure_ascii=False),
+    )
+
+
+def _hex_id(value: int, width: int) -> str | None:
+    return f"{value:0{width}x}" if value else None
+
+
+class MetergraphGenAIExporter(SpanExporter):
+    """Export completed OpenTelemetry GenAI spans through MeterGraph."""
+
+    def __init__(self) -> None:
+        metergraph.init()
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        runtime = _get_runtime()
+        if runtime is None:
+            return SpanExportResult.SUCCESS
+        for span in spans:
+            try:
+                self._export_span(runtime, span)
+            except Exception:
+                # Observability must never break the application or its OTel pipeline.
+                continue
+        return SpanExportResult.SUCCESS
+
+    def _export_span(self, runtime: Any, span: ReadableSpan) -> None:
+        attributes = span.attributes or {}
+        model = _attribute(attributes, "gen_ai.request.model")
+        provider = _attribute(attributes, "gen_ai.provider.name") or _attribute(
+            attributes, "gen_ai.system"
+        )
+        if not isinstance(model, str) or not isinstance(provider, str):
+            return
+
+        operation = _attribute(attributes, "gen_ai.operation.name")
+        operation = operation if isinstance(operation, str) else "inference"
+        request: dict[str, Any] = {"model": model}
+        system, messages = _request_content(attributes)
+        if system is not None:
+            request["system_instructions"] = system
+        if messages is not None:
+            request["messages"] = messages
+
+        context = span.context
+        parent = span.parent
+        resource_attributes = (
+            span.resource.attributes if span.resource is not None else {}
+        )
+        function_name = _attribute(attributes, "code.function.name")
+        if not isinstance(function_name, str) or not function_name:
+            function_name = span.name
+        function_module = _attribute(attributes, "code.namespace") or _attribute(
+            resource_attributes, "service.name"
+        )
+        if not isinstance(function_module, str):
+            function_module = None
+        trace_id = _hex_id(context.trace_id, 32) if context is not None else None
+        span_id = _hex_id(context.span_id, 16) if context is not None else None
+        parent_span_id = _hex_id(parent.span_id, 16) if parent is not None else None
+        call = runtime.call_state(
+            provider,
+            operation,
+            request,
+            context=CaptureContext(
+                route=operation,
+                trace_id=trace_id,
+                trace_name=span.name,
+                parent_span_id=parent_span_id,
+                func_name=function_name,
+                func_module=function_module,
+            ),
+        )
+        if span_id is not None:
+            call.span_id = span_id
+        if span.start_time is not None:
+            call.ts = datetime.fromtimestamp(
+                span.start_time / 1_000_000_000, tz=timezone.utc
+            ).isoformat()
+        if span.start_time is not None and span.end_time is not None:
+            duration_seconds = max(0, span.end_time - span.start_time) / 1_000_000_000
+            call.started = time.perf_counter() - duration_seconds
+
+        response_model = _attribute(attributes, "gen_ai.response.model")
+        finish_reason = _first_string(
+            _attribute(attributes, "gen_ai.response.finish_reasons")
+        )
+        response = {
+            "model": response_model if isinstance(response_model, str) else model,
+            "usage": {
+                "input_tokens": _attribute(
+                    attributes, "gen_ai.usage.input_tokens"
+                ),
+                "output_tokens": _attribute(
+                    attributes, "gen_ai.usage.output_tokens"
+                ),
+            },
+            "finish_reason": finish_reason,
+            "choices": (
+                [{"finish_reason": finish_reason}]
+                if finish_reason is not None
+                else []
+            ),
+        }
+        output_text = _text_from_output_messages(
+            _attribute(attributes, "gen_ai.output.messages")
+        )
+        if span.status.status_code is StatusCode.ERROR:
+            call.finish(
+                response,
+                error=OpenTelemetrySpanError(
+                    span.status.description or "OpenTelemetry GenAI span failed"
+                ),
+                response_text=output_text,
+            )
+        else:
+            call.finish(response, response_text=output_text)
+
+    def force_flush(self, timeout_millis: int = 30_000) -> bool:
+        return metergraph.flush(max(0, timeout_millis) / 1000)
+
+    def shutdown(self) -> None:
+        metergraph.shutdown()
+
+
+__all__ = ["MetergraphGenAIExporter"]

metergraph-0.6.0/README.md → metergraph-0.6.2/src/metergraph.egg-info/PKG-INFO

@@ -1,3 +1,28 @@
+Metadata-Version: 2.4
+Name: metergraph
+Version: 0.6.2
+Summary: Fire-and-forget LLM spend capture for Metergraph
+Author: Pioneer Square Labs
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://www.metergraph.dev/
+Project-URL: Repository, https://github.com/PioneerSquareLabs/metergraphsdk
+Project-URL: Issues, https://github.com/PioneerSquareLabs/metergraphsdk/issues
+Keywords: llm,observability,openai,anthropic,gemini,vercel-ai-gateway,cost-tracking
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: otel
+Requires-Dist: opentelemetry-sdk>=1.30; extra == "otel"
+Provides-Extra: dev
+Requires-Dist: build>=1; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: openai<3,>=2.50.0; extra == "dev"
+Requires-Dist: anthropic<1,>=0.40; extra == "dev"
+Requires-Dist: google-genai>=1; extra == "dev"
+Requires-Dist: opentelemetry-sdk>=1.30; extra == "dev"
+
 # metergraph (Python)
 
 Zero-runtime-dependency capture for OpenAI, Anthropic, Gemini, and Python
@@ -16,12 +41,15 @@ from openai import OpenAI
 metergraph.init(repository="owner/repository")
 # Anthropic() and google-genai's genai.Client() wrap the same way.
 client = metergraph.wrap(OpenAI())
-metergraph.set_session("ticket-123")
 
-with metergraph.trace("ticket-workflow"):
-    with metergraph.route("ticket-classifier", unit="answer"):
-        model = metergraph.model_for("ticket-classifier", default="gpt-4.1-mini")
-        client.chat.completions.create(model=model, messages=[...])
+with metergraph.context(
+    session_id="ticket-123",
+    tags={"customer": "acme"},
+):
+    with metergraph.trace("ticket-workflow"):
+        with metergraph.route("ticket-classifier", unit="answer"):
+            model = metergraph.model_for("ticket-classifier", default="gpt-4.1-mini")
+            client.chat.completions.create(model=model, messages=[...])
 
 # Emit this after the user-visible task resolves. It shares the bounded async
 # transport and contains no prompt or output content.
@@ -35,6 +63,14 @@ metergraph.record_outcome(
 )
 ```
 
+Use `metergraph.context()` for request or job identity. It follows async work
+created inside the scope and is restored afterward, so concurrent and reused
+workers cannot leak session IDs or tags into one another. The narrower
+`metergraph.session()` and `metergraph.tags()` scopes compose with it.
+`metergraph.set_default_tags()` sets process-wide service metadata. Legacy
+`set_session()` and `set_tags()` calls only update an active Metergraph scope;
+outside one they warn once and do nothing.
+
 Vercel's supported Python surface is AI Gateway through the OpenAI or
 Anthropic SDK. Point either client at the public gateway and `wrap()` detects
 it automatically:
@@ -61,12 +97,44 @@ async, streaming, tool calls, and OpenAI Responses API calls are captured. Use
 `metergraph.wrap(client, provider="vercel")` only when a compatible client is
 behind a custom gateway URL that cannot be detected automatically.
 
+## OpenTelemetry GenAI export
+
+`MetergraphGenAIExporter` is a standard OpenTelemetry span exporter for GenAI
+semantic-convention spans. The currently qualified integration is LiteLLM:
+install the optional integration and configure MeterGraph as LiteLLM's custom
+exporter. Existing LiteLLM call sites remain unchanged and must not also be
+wrapped.
+
+```bash
+python -m pip install 'metergraph[otel]' 'litellm[proxy]>=1.96.2,<2'
+```
+
+```python
+import litellm
+from litellm.integrations.opentelemetry import OpenTelemetry, OpenTelemetryConfig
+from metergraph.opentelemetry import MetergraphGenAIExporter
+
+litellm.callbacks.append(OpenTelemetry(OpenTelemetryConfig(
+    exporter=MetergraphGenAIExporter(),
+    capture_message_content="SPAN_ONLY",
+)))
+```
+
+The exporter preserves OpenTelemetry trace identity, model/provider metadata,
+token usage, latency, system instructions, ordered messages, and text output.
+Message content is explicitly enabled because it may be sensitive. Text parts
+are retained and replayable in the current POC pipeline. Calls containing other
+part types retain their model, usage, timing, and status metadata, but those
+parts are not replayable yet. See the runnable
+[`python-litellm-otel` example](../examples/python-litellm-otel/).
+
 Configuration:
 
 - `METERGRAPH_APP_TOKEN` — required bearer token
 - `METERGRAPH_INGEST_URL` — optional override; defaults to the hosted HTTPS endpoint
 - `METERGRAPH_REPOSITORY` — optional `owner/repository` identity; used by [MeterGraph Bot](https://github.com/apps/metergraph)
 - `METERGRAPH_CAPTURE_TEXT=0` — opt out of content capture globally
+- `METERGRAPH_TEXT_MAX_BYTES` — per-field content limit; defaults to 1 MiB
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
@@ -88,11 +156,13 @@ identity, it warns once and continues capture without repository attribution.
 
 Delivery is bounded and off the request path. Queue overflow or a collector
 outage drops capture and increments internal counters; it never changes the
-provider call. Each wire batch is bounded to 512 KiB after optional gzip.
+provider call. Each wire batch is bounded to 4 MiB after optional gzip.
 By default, Metergraph captures the scrubbed provider request and a normalized
 response envelope, including assistant content and tool calls. Provider
 credentials and transport headers are removed. Request and response are each
-limited to 100 KiB of UTF-8 with an explicit truncation marker.
+limited to 1 MiB of UTF-8 by default with an explicit truncation marker. Set
+`METERGRAPH_TEXT_MAX_BYTES` or initialize with `text_max_bytes=...` to raise
+the per-field limit for larger prompts and responses.
 `capture_text=False` on `route()` or `trace()` overrides the global content
 policy for a sensitive operation. The equivalent initialization option is
 `metergraph.init(capture_text=False)`. The public open-source server continues

{metergraph-0.6.0 → metergraph-0.6.2}/src/metergraph.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/metergraph/_template.py
 src/metergraph/_track.py
 src/metergraph/_transport.py
 src/metergraph/_version.py
+src/metergraph/opentelemetry.py
 src/metergraph.egg-info/PKG-INFO
 src/metergraph.egg-info/SOURCES.txt
 src/metergraph.egg-info/dependency_links.txt

metergraph-0.6.2/src/metergraph.egg-info/requires.txt

@@ -0,0 +1,11 @@
+
+[dev]
+build>=1
+pytest>=8
+openai<3,>=2.50.0
+anthropic<1,>=0.40
+google-genai>=1
+opentelemetry-sdk>=1.30
+
+[otel]
+opentelemetry-sdk>=1.30

metergraph-0.6.0/src/metergraph/_repo_config.py

@@ -1,165 +0,0 @@
-"""SDK 0.4+ repository-aware ingestion: discover, detect, and write
-.metergraph/config.json.
-
-Discovery is purely file-based (never shells out to git), so a committed
-config is honored in production without needing a .git directory at all.
-Detection + write only ever runs when discovery finds nothing: it shells out
-to git to find the repo's top level and GitHub origin, then writes the config
-there exactly once. An existing file is always authoritative and is never
-overwritten. Every failure mode here is fail-open -- callers get None and
-fall back to app-token ingestion, never an exception.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import subprocess
-from dataclasses import dataclass
-
-
-log = logging.getLogger("metergraph")
-
-CONFIG_DIRNAME = ".metergraph"
-CONFIG_FILENAME = "config.json"
-SUPPORTED_CONFIG_VERSION = 2
-_MAX_WALK_UP = 64
-_GIT_TIMEOUT_SECONDS = 5
-
-_REMOTE_PATTERNS = (
-    re.compile(r"^git@github\.com:(?P<path>[^/]+/[^/]+?)(\.git)?/?$"),
-    re.compile(r"^https://github\.com/(?P<path>[^/]+/[^/]+?)(\.git)?/?$"),
-    re.compile(r"^ssh://git@github\.com/(?P<path>[^/]+/[^/]+?)(\.git)?/?$"),
-)
-
-
-@dataclass(frozen=True)
-class RepoConfig:
-    repository: str
-    repo_root: str
-
-
-def normalize_github_remote(url: str) -> str | None:
-    """Return 'owner/repo' from a GitHub SSH or HTTPS remote URL, or None
-    if the URL isn't a recognized GitHub origin."""
-    trimmed = url.strip()
-    for pattern in _REMOTE_PATTERNS:
-        match = pattern.match(trimmed)
-        if match:
-            return match.group("path")
-    return None
-
-
-def discover_repo_config(app_root: str) -> RepoConfig | None:
-    """Walk upward from app_root looking for .metergraph/config.json.
-
-    Returns None -- silently, this is the normal v1 state -- when nothing is
-    found. Logs a warning (but still returns None) if a config file exists
-    but fails to parse or carries an unsupported schema version.
-    """
-    current = os.path.realpath(app_root)
-    for _ in range(_MAX_WALK_UP):
-        candidate = os.path.join(current, CONFIG_DIRNAME, CONFIG_FILENAME)
-        if os.path.isfile(candidate):
-            return _load(candidate, current)
-        parent = os.path.dirname(current)
-        if parent == current:
-            break
-        current = parent
-    return None
-
-
-def _load(path: str, repo_root: str) -> RepoConfig | None:
-    try:
-        with open(path, "r", encoding="utf-8") as handle:
-            doc = json.load(handle)
-    except (OSError, json.JSONDecodeError) as exc:
-        log.warning("metergraph: found %s but could not read it: %s", path, exc)
-        return None
-    if not isinstance(doc, dict) or doc.get("version", SUPPORTED_CONFIG_VERSION) != SUPPORTED_CONFIG_VERSION:
-        log.warning(
-            "metergraph: %s has an unsupported schema version; ignoring "
-            "(expected version %d)",
-            path,
-            SUPPORTED_CONFIG_VERSION,
-        )
-        return None
-    repository = doc.get("repository")
-    if not isinstance(repository, str) or "/" not in repository:
-        log.warning("metergraph: %s is missing a valid 'repository' field; ignoring", path)
-        return None
-    return RepoConfig(repository=repository, repo_root=repo_root)
-
-
-def _run_git(args: list[str], cwd: str) -> str | None:
-    try:
-        result = subprocess.run(
-            ["git", *args],
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            timeout=_GIT_TIMEOUT_SECONDS,
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-    if result.returncode != 0:
-        return None
-    output = result.stdout.strip()
-    return output or None
-
-
-def _git_top_level(app_root: str) -> str | None:
-    top = _run_git(["rev-parse", "--show-toplevel"], app_root)
-    return os.path.realpath(top) if top else None
-
-
-def _git_origin_url(repo_root: str) -> str | None:
-    return _run_git(["remote", "get-url", "origin"], repo_root)
-
-
-def _write_config_atomically(repo_root: str, repository: str) -> RepoConfig | None:
-    """Create .metergraph/config.json if -- and only if -- it doesn't
-    already exist. Uses O_CREAT|O_EXCL for an atomic create-only-if-absent;
-    a concurrent writer (or a file that appeared between discovery and this
-    call) always wins over us, and we simply read back whatever is there."""
-    config_dir = os.path.join(repo_root, CONFIG_DIRNAME)
-    config_path = os.path.join(config_dir, CONFIG_FILENAME)
-    payload = json.dumps({"version": SUPPORTED_CONFIG_VERSION, "repository": repository}) + "\n"
-    try:
-        os.makedirs(config_dir, exist_ok=True)
-        fd = os.open(config_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o644)
-        try:
-            os.write(fd, payload.encode("utf-8"))
-        finally:
-            os.close(fd)
-    except FileExistsError:
-        pass
-    except OSError as exc:
-        log.warning("metergraph: could not write %s: %s", config_path, exc)
-        return None
-    return _load(config_path, repo_root)
-
-
-def ensure_repo_config(app_root: str) -> RepoConfig | None:
-    """Discover an existing repo config, or detect+write one once at the
-    git top level. Fail-open: any detection or write failure returns None
-    (app-token ingestion), never raises."""
-    existing = discover_repo_config(app_root)
-    if existing is not None:
-        return existing
-    try:
-        repo_root = _git_top_level(app_root)
-        if repo_root is None:
-            return None
-        origin = _git_origin_url(repo_root)
-        if origin is None:
-            return None
-        repository = normalize_github_remote(origin)
-        if repository is None:
-            return None
-        return _write_config_atomically(repo_root, repository)
-    except Exception as exc:
-        log.debug("metergraph: repo config detection failed: %s", exc)
-        return None

metergraph-0.6.0/src/metergraph.egg-info/requires.txt

@@ -1,7 +0,0 @@
-
-[dev]
-build>=1
-pytest>=8
-openai>=2.50.0
-anthropic>=0.40
-google-genai>=1