metergraph 0.3.0__tar.gz → 0.4.0__tar.gz

{metergraph-0.3.0 → metergraph-0.4.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: metergraph
-Version: 0.3.0
+Version: 0.4.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,cost-tracking
+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
@@ -21,7 +21,8 @@ Requires-Dist: google-genai>=1; extra == "dev"
 
 # metergraph (Python)
 
-Zero-runtime-dependency capture for OpenAI, Anthropic, and Gemini clients.
+Zero-runtime-dependency capture for OpenAI, Anthropic, Gemini, and Python
+Vercel AI Gateway clients.
 `wrap()` initializes capture from the environment, so setup is one line per
 client; call `metergraph.init(...)` before the first `wrap()` only to pass
 options in code.
@@ -51,6 +52,31 @@ metergraph.record_outcome(
 )
 ```
 
+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:
+
+```python
+import os
+import metergraph
+from openai import OpenAI
+
+gateway = metergraph.wrap(OpenAI(
+    api_key=os.getenv("AI_GATEWAY_API_KEY") or os.getenv("VERCEL_OIDC_TOKEN"),
+    base_url="https://ai-gateway.vercel.sh/v1",
+))
+
+gateway.chat.completions.create(
+    model="anthropic/claude-sonnet-4.6",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+Creator-qualified model IDs are normalized for gateway catalog pricing. Sync,
+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.
+
 Configuration:
 
 - `METERGRAPH_APP_TOKEN` — required bearer token
@@ -59,10 +85,18 @@ Configuration:
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
+SDK 0.4 associates traces with their GitHub repository automatically. On the
+first `init()` in a Git checkout, it reads the `origin` remote and creates
+`.metergraph/config.json` at the repository root if that file is absent.
+Commit this non-secret file so production can use repository-aware ingest
+without Git metadata. An existing file is authoritative and is never changed
+by the SDK. If discovery or creation is unavailable, ingest remains compatible
+with protocol v1.
+
 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.
-SDK 0.3 captures the scrubbed provider request and a normalized response
+SDK 0.4 captures the scrubbed provider request and a normalized response
 envelope, including assistant content and tool calls, by default. Provider
 credentials and transport headers are removed. Request and response are each
 limited to 100 KiB of UTF-8 with an explicit truncation marker.
@@ -101,10 +135,13 @@ Instrument this codebase's LLM API costs with the `metergraph` PyPI package
 (https://github.com/PioneerSquareLabs/metergraphsdk): pip install metergraph,
 then wrap every OpenAI()/AsyncOpenAI(), Anthropic()/AsyncAnthropic(), and
 genai.Client() construction in place, e.g. client = metergraph.wrap(OpenAI()).
+OpenAI or Anthropic clients pointed at https://ai-gateway.vercel.sh are Vercel
+AI Gateway clients and are detected automatically; keep their creator/model ID
+and AI_GATEWAY_API_KEY / VERCEL_OIDC_TOKEN configuration unchanged.
 wrap() returns the same client and initializes itself from the environment:
 METERGRAPH_APP_TOKEN is required (capture is silently off without it) and
 METERGRAPH_INGEST_URL is only for self-hosted servers. Add both to
-.env.example, and never commit a real token. SDK 0.3 captures scrubbed provider
+.env.example, and never commit a real token. SDK 0.4 captures scrubbed provider
 requests and normalized responses by default for the hosted dashboard; use
 METERGRAPH_CAPTURE_TEXT=0 or capture_text=False around sensitive operations.
 Provider credentials and transport headers must never be captured. Capture is

{metergraph-0.3.0 → metergraph-0.4.0}/README.md

@@ -1,6 +1,7 @@
 # metergraph (Python)
 
-Zero-runtime-dependency capture for OpenAI, Anthropic, and Gemini clients.
+Zero-runtime-dependency capture for OpenAI, Anthropic, Gemini, and Python
+Vercel AI Gateway clients.
 `wrap()` initializes capture from the environment, so setup is one line per
 client; call `metergraph.init(...)` before the first `wrap()` only to pass
 options in code.
@@ -30,6 +31,31 @@ metergraph.record_outcome(
 )
 ```
 
+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:
+
+```python
+import os
+import metergraph
+from openai import OpenAI
+
+gateway = metergraph.wrap(OpenAI(
+    api_key=os.getenv("AI_GATEWAY_API_KEY") or os.getenv("VERCEL_OIDC_TOKEN"),
+    base_url="https://ai-gateway.vercel.sh/v1",
+))
+
+gateway.chat.completions.create(
+    model="anthropic/claude-sonnet-4.6",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+Creator-qualified model IDs are normalized for gateway catalog pricing. Sync,
+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.
+
 Configuration:
 
 - `METERGRAPH_APP_TOKEN` — required bearer token
@@ -38,10 +64,18 @@ Configuration:
 - `METERGRAPH_DISABLED=1` — process kill switch
 - `METERGRAPH_QUEUE_SIZE`, `METERGRAPH_BATCH_SIZE`, `METERGRAPH_FLUSH_SECONDS`
 
+SDK 0.4 associates traces with their GitHub repository automatically. On the
+first `init()` in a Git checkout, it reads the `origin` remote and creates
+`.metergraph/config.json` at the repository root if that file is absent.
+Commit this non-secret file so production can use repository-aware ingest
+without Git metadata. An existing file is authoritative and is never changed
+by the SDK. If discovery or creation is unavailable, ingest remains compatible
+with protocol v1.
+
 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.
-SDK 0.3 captures the scrubbed provider request and a normalized response
+SDK 0.4 captures the scrubbed provider request and a normalized response
 envelope, including assistant content and tool calls, by default. Provider
 credentials and transport headers are removed. Request and response are each
 limited to 100 KiB of UTF-8 with an explicit truncation marker.
@@ -80,10 +114,13 @@ Instrument this codebase's LLM API costs with the `metergraph` PyPI package
 (https://github.com/PioneerSquareLabs/metergraphsdk): pip install metergraph,
 then wrap every OpenAI()/AsyncOpenAI(), Anthropic()/AsyncAnthropic(), and
 genai.Client() construction in place, e.g. client = metergraph.wrap(OpenAI()).
+OpenAI or Anthropic clients pointed at https://ai-gateway.vercel.sh are Vercel
+AI Gateway clients and are detected automatically; keep their creator/model ID
+and AI_GATEWAY_API_KEY / VERCEL_OIDC_TOKEN configuration unchanged.
 wrap() returns the same client and initializes itself from the environment:
 METERGRAPH_APP_TOKEN is required (capture is silently off without it) and
 METERGRAPH_INGEST_URL is only for self-hosted servers. Add both to
-.env.example, and never commit a real token. SDK 0.3 captures scrubbed provider
+.env.example, and never commit a real token. SDK 0.4 captures scrubbed provider
 requests and normalized responses by default for the hosted dashboard; use
 METERGRAPH_CAPTURE_TEXT=0 or capture_text=False around sensitive operations.
 Provider credentials and transport headers must never be captured. Capture is

{metergraph-0.3.0 → metergraph-0.4.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "metergraph"
-version = "0.3.0"
+version = "0.4.0"
 description = "Fire-and-forget LLM spend capture for Metergraph"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "Apache-2.0"
 authors = [{ name = "Pioneer Square Labs" }]
-keywords = ["llm", "observability", "openai", "anthropic", "gemini", "cost-tracking"]
+keywords = ["llm", "observability", "openai", "anthropic", "gemini", "vercel-ai-gateway", "cost-tracking"]
 classifiers = [
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Libraries :: Python Modules",

{metergraph-0.3.0 → metergraph-0.4.0}/src/metergraph/__init__.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import atexit
 import logging
+import math
 import os
 import uuid
 from datetime import datetime, timezone
@@ -13,6 +14,8 @@ from ._capture import 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 ._repo_config import ensure_repo_config
+from ._session import SessionManager
 from ._track import track
 from ._transport import Writer
 from ._version import SDK_VERSION
@@ -23,6 +26,7 @@ DEFAULT_INGEST_URL = "https://d2xus7mp8zdv6t.cloudfront.net"
 log = logging.getLogger("metergraph")
 _writer: Writer | None = None
 _config: ConfigPoller | None = None
+_session_manager: SessionManager | None = None
 _initialized = False
 _warned_no_token = False
 
@@ -46,7 +50,7 @@ def init(
     disabled: bool | None = None,
 ) -> None:
     """Initialize capture. This function is idempotent and never raises."""
-    global _initialized, _warned_no_token, _writer, _config
+    global _initialized, _warned_no_token, _writer, _config, _session_manager
     if _initialized:
         return
     if os.getenv("METERGRAPH_DISABLED") == "1" or disabled:
@@ -64,9 +68,23 @@ def init(
         return
     _initialized = True
     try:
+        app_root_resolved = os.path.realpath(app_root or os.getcwd())
+        repo_config = ensure_repo_config(app_root_resolved)
+        session = (
+            SessionManager(
+                token,
+                ingest_url,
+                repository=repo_config.repository,
+                sdk_version=SDK_VERSION,
+            )
+            if repo_config is not None
+            else None
+        )
+        _session_manager = session
         _writer = Writer(
             token,
             ingest_url,
+            session=session,
             queue_size=int(os.getenv("METERGRAPH_QUEUE_SIZE", "2000")),
             batch_size=int(os.getenv("METERGRAPH_BATCH_SIZE", "100")),
             flush_seconds=float(os.getenv("METERGRAPH_FLUSH_SECONDS", "5")),
@@ -78,7 +96,8 @@ def init(
                 else capture_text
             ),
             redact=redact,
-            app_root=os.path.realpath(app_root or os.getcwd()),
+            app_root=app_root_resolved,
+            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(
@@ -109,16 +128,20 @@ def init(
             _writer.shutdown()
         _writer = None
         _config = None
+        _session_manager = None
         log.warning(
             "Metergraph initialization failed; application is running uninstrumented"
         )
 
 
 def wrap(client: Any, *, provider: str | None = None) -> Any:
-    """Wrap an OpenAI, Anthropic, or Google client for capture.
+    """Wrap an OpenAI, Anthropic, Google, or Vercel AI Gateway client.
 
     Calls init() automatically, so with env-var configuration this is the
-    only setup line needed. Call init(...) first to pass options in code.
+    only setup line needed. OpenAI and Anthropic clients using Vercel's public
+    AI Gateway URL are detected automatically; pass ``provider="vercel"`` to
+    force gateway handling for a compatible client with a custom URL. Call
+    init(...) first to pass Metergraph options in code.
     """
     init()
     return _wrap(client, provider=provider)
@@ -154,26 +177,33 @@ def record_outcome(
     event_id = str(event_id or uuid.uuid4()).strip()[:128]
     try:
         feedback_score = float(feedback_score) if feedback_score is not None else None
-        turns_to_resolution = (
-            int(turns_to_resolution) if turns_to_resolution is not None else None
-        )
         edit_distance_ratio = (
             float(edit_distance_ratio) if edit_distance_ratio is not None else None
         )
-        regeneration_count = (
-            int(regeneration_count) if regeneration_count is not None else None
-        )
     except (TypeError, ValueError, OverflowError):
         return False
     if not route_name or not model or not session_key or not event_id:
         return False
-    if feedback_score is not None and not -1 <= feedback_score <= 1:
+    if feedback_score is not None and (
+        not math.isfinite(feedback_score) or not -1 <= feedback_score <= 1
+    ):
         return False
-    if turns_to_resolution is not None and not 1 <= turns_to_resolution <= 1_000_000:
+    if turns_to_resolution is not None and (
+        isinstance(turns_to_resolution, bool)
+        or not isinstance(turns_to_resolution, int)
+        or not 1 <= turns_to_resolution <= 1_000_000
+    ):
         return False
-    if edit_distance_ratio is not None and not 0 <= edit_distance_ratio <= 1:
+    if edit_distance_ratio is not None and (
+        not math.isfinite(edit_distance_ratio)
+        or not 0 <= edit_distance_ratio <= 1
+    ):
         return False
-    if regeneration_count is not None and not 0 <= regeneration_count <= 1_000_000:
+    if regeneration_count is not None and (
+        isinstance(regeneration_count, bool)
+        or not isinstance(regeneration_count, int)
+        or not 0 <= regeneration_count <= 1_000_000
+    ):
         return False
     if escalated is not None and not isinstance(escalated, bool):
         return False
@@ -203,13 +233,16 @@ def flush(timeout: float = 3.0) -> bool:
 
 
 def shutdown() -> None:
-    global _writer, _config
+    global _writer, _config, _session_manager
     if _config:
         _config.stop()
         _config = None
     if _writer:
         _writer.shutdown()
         _writer = None
+    if _session_manager:
+        _session_manager.stop()
+        _session_manager = None
     set_runtime(None)
 
 

{metergraph-0.3.0 → metergraph-0.4.0}/src/metergraph/_capture.py

@@ -6,6 +6,7 @@ import functools
 import inspect
 import json
 import logging
+import math
 import os
 import platform
 import secrets
@@ -15,6 +16,7 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Mapping
+from urllib.parse import urlsplit
 
 from ._context import CaptureContext, snapshot
 from ._template import scrub, template_hash
@@ -39,8 +41,17 @@ def _first(value: Any) -> Any:
 
 def _int(value: Any) -> int | None:
     try:
-        return int(value) if value is not None else None
-    except (TypeError, ValueError):
+        if value is None or isinstance(value, bool):
+            return None
+        if isinstance(value, int):
+            return value if value >= 0 else None
+        parsed = float(value)
+        return (
+            int(parsed)
+            if math.isfinite(parsed) and parsed >= 0 and parsed.is_integer()
+            else None
+        )
+    except (TypeError, ValueError, OverflowError):
         return None
 
 
@@ -202,10 +213,33 @@ def _chunk_text(chunk: Any) -> str | None:
     return None
 
 
+def _chunk_has_output(chunk: Any) -> bool:
+    """Recognize the first user-visible text, reasoning, or tool output."""
+    if _chunk_text(chunk):
+        return True
+    for choice in _get(chunk, "choices", []) or []:
+        if _get(_get(choice, "delta"), "tool_calls"):
+            return True
+    kind = _get(chunk, "type")
+    delta = _get(chunk, "delta")
+    if isinstance(delta, str) and "reasoning" in str(kind):
+        return bool(delta)
+    if _get(delta, "thinking") or _get(delta, "reasoning"):
+        return True
+    if kind == "content_block_start":
+        return _get(_get(chunk, "content_block"), "type") == "tool_use"
+    if kind == "content_block_delta":
+        return _get(_get(chunk, "delta"), "type") == "input_json_delta"
+    for candidate in _get(chunk, "candidates", []) or []:
+        for part in _get(_get(candidate, "content"), "parts", []) or []:
+            if _get(part, "function_call") or _get(part, "functionCall"):
+                return True
+    return False
+
+
 def _usage_only_chunk(chunk: Any, call: "CallState") -> bool:
     return (
-        call.provider == "openai"
-        and call.endpoint == "chat.completions"
+        call.endpoint == "chat.completions"
         and _get(chunk, "choices") == []
         and _get(chunk, "usage") is not None
     )
@@ -522,10 +556,11 @@ def _tool_events(
 
 
 def _capture_frames(
-    app_root: str, skip_frames: tuple[str, ...]
+    app_root: str, skip_frames: tuple[str, ...], repo_root: str | None = None
 ) -> tuple[str | None, str | None, list[dict]]:
     frames: list[dict] = []
     root = os.path.realpath(app_root)
+    repo_root_real = os.path.realpath(repo_root) if repo_root else None
     frame = sys._getframe(2)
     while frame is not None and len(frames) < 5:
         filename = os.path.realpath(frame.f_code.co_filename)
@@ -535,7 +570,19 @@ def _capture_frames(
             relative = os.path.relpath(filename, root)
             module = str(Path(relative).with_suffix("")).replace(os.sep, ".")
             qualname = getattr(frame.f_code, "co_qualname", frame.f_code.co_name)
-            frames.append({"m": module, "f": qualname, "l": frame.f_lineno})
+            entry = {"m": module, "f": qualname, "l": frame.f_lineno}
+            try:
+                inside_repo = bool(
+                    repo_root_real
+                    and os.path.commonpath((filename, repo_root_real)) == repo_root_real
+                )
+            except ValueError:
+                inside_repo = False
+            if inside_repo:
+                entry["p"] = os.path.relpath(filename, repo_root_real).replace(
+                    os.sep, "/"
+                )
+            frames.append(entry)
         frame = frame.f_back
     if not frames:
         return None, None, []
@@ -547,6 +594,7 @@ class Options:
     capture_text: bool = True
     redact: Callable[[str, str], str] | None = None
     app_root: str = os.getcwd()
+    repo_root: str | None = None
     skip_frames: tuple[str, ...] = ()
     environment: str | None = None
     text_max_bytes: int = 100 * 1024
@@ -575,6 +623,7 @@ class Runtime:
                 "threading.py",
                 *self.options.skip_frames,
             ),
+            self.options.repo_root,
         )
         return CallState(
             runtime=self,
@@ -683,6 +732,11 @@ class CallState:
                 }
                 for item in tool_calls
             ]
+        tool_names = (
+            list(dict.fromkeys(item["name"] for item in full_tool_calls))
+            if full_tool_calls
+            else None
+        )
         effective_status = status or (
             "error" if error else _stop_reason(response) or "success"
         )
@@ -720,6 +774,7 @@ class CallState:
             "unit_name": self.context.unit_name,
             "unit_count": self.context.unit_count,
             "tool_calls": tool_calls,
+            "tool_names": tool_names,
             "endpoint": self.endpoint,
             "request_id": _request_id(response),
             "batch": self.request.get("batch") is True,
@@ -763,14 +818,14 @@ class _StreamState:
         self.last = value
         self.chunks.append(value)
         text = _chunk_text(value)
+        if self.ttft_ms is None and _chunk_has_output(value):
+            self.ttft_ms = round((time.perf_counter() - self.call.started) * 1000)
         if text:
-            if self.ttft_ms is None:
-                self.ttft_ms = round((time.perf_counter() - self.call.started) * 1000)
             self.parts.append(text)
         return value
 
     def finish(
-        self, status: str = "success", error: BaseException | None = None
+        self, status: str | None = None, error: BaseException | None = None
     ) -> None:
         response = self.last
         if not error:
@@ -796,7 +851,7 @@ class _StreamState:
         )
 
     async def finish_async(
-        self, status: str = "success", error: BaseException | None = None
+        self, status: str | None = None, error: BaseException | None = None
     ) -> None:
         response = self.last
         if not error:
@@ -1198,7 +1253,14 @@ def _patch_anthropic_batch_results(owner: Any) -> bool:
     return True
 
 
-def _patch(owner: Any, method_name: str, provider: str, endpoint: str) -> bool:
+def _patch(
+    owner: Any,
+    method_name: str,
+    provider: str,
+    endpoint: str,
+    *,
+    gateway: bool = False,
+) -> bool:
     original = getattr(owner, method_name, None)
     if not callable(original):
         return False
@@ -1223,7 +1285,8 @@ def _patch(owner: Any, method_name: str, provider: str, endpoint: str) -> bool:
                 else:
                     kwargs = {**kwargs, "stream_options": {"include_usage": True}}
         request = _request(args, kwargs)
-        call = runtime.call_state(provider, endpoint, request)
+        capture_provider = _gateway_provider(request) if gateway else provider
+        call = runtime.call_state(capture_provider, endpoint, request)
         try:
             result = original(*args, **kwargs)
         except BaseException as exc:
@@ -1321,14 +1384,44 @@ def _resolve(client: Any, path: str) -> Any:
     return obj
 
 
-def _apply_seams(client: Any, provider: str) -> list[str]:
+_VERCEL_GATEWAY_HOST = "ai-gateway.vercel.sh"
+_VERCEL_PROVIDER_ALIASES = {"gateway", "vercel", "vercel-ai-gateway"}
+
+
+def _uses_vercel_gateway(client: Any) -> bool:
+    """Recognize the public AI Gateway URL exposed by supported Python SDKs."""
+    base_url = getattr(client, "base_url", None) or getattr(
+        client, "_base_url", None
+    )
+    if base_url is None:
+        return False
+    try:
+        return urlsplit(str(base_url).strip()).hostname == _VERCEL_GATEWAY_HOST
+    except (TypeError, ValueError):
+        return False
+
+
+def _gateway_provider(request: Mapping[str, Any]) -> str:
+    """Use the creator in Vercel's required `creator/model` identifier."""
+    model = str(request.get("model") or "").strip().lower()
+    creator, separator, _ = model.partition("/")
+    return creator if separator and creator else "vercel-ai-gateway"
+
+
+def _apply_seams(client: Any, provider: str, *, gateway: bool = False) -> list[str]:
     patched: list[str] = []
     for seam in SEAM_TABLES.get(provider, ()):
         try:
             owner = _resolve(client, seam.path)
         except Exception:
             continue  # a pathological client property must never break wrap()
-        if owner is not None and _patch(owner, seam.method, provider, seam.endpoint):
+        if owner is not None and _patch(
+            owner,
+            seam.method,
+            provider,
+            seam.endpoint,
+            gateway=gateway,
+        ):
             patched.append(f"{seam.path}.{seam.method}")
     return patched
 
@@ -1356,22 +1449,42 @@ def _apply_batch_extras(client: Any, provider: str) -> int:
 def wrap(client: Any, *, provider: str | None = None) -> Any:
     """Patch supported resource methods on an OpenAI, Anthropic, or Google client.
 
+    OpenAI and Anthropic clients pointed at Vercel AI Gateway are recognized
+    automatically. ``provider="vercel"`` can force gateway attribution for a
+    compatible client whose public base URL has been customized.
+
     Never raises: an unrecognized client shape, or an exception while probing
     it, results in an unmodified, uninstrumented client — not a crash.
     """
     try:
-        resolved_provider = provider or _detect_provider(client)
-        patched = _apply_seams(client, resolved_provider)
-        patched_count = len(patched) + _apply_batch_extras(client, resolved_provider)
+        gateway = (
+            provider.strip().lower() in _VERCEL_PROVIDER_ALIASES
+            if isinstance(provider, str)
+            else _uses_vercel_gateway(client)
+        )
+        resolved_provider = (
+            _detect_provider(client)
+            if gateway
+            else provider or _detect_provider(client)
+        )
+        patched = _apply_seams(client, resolved_provider, gateway=gateway)
+        patched_count = len(patched)
+        if not gateway:
+            patched_count += _apply_batch_extras(client, resolved_provider)
+        client_label = (
+            f"Vercel AI Gateway via {resolved_provider}"
+            if gateway
+            else resolved_provider
+        )
         if not patched_count:
             log.warning(
-                "Metergraph found no supported methods on %s client", resolved_provider
+                "Metergraph found no supported methods on %s client", client_label
             )
         else:
             log.info(
                 "Metergraph patched %d seam(s) on %s client: %s",
                 patched_count,
-                resolved_provider,
+                client_label,
                 ", ".join(patched) or "(batch-only)",
             )
     except Exception: