smartpipe-cli 1.3.0__py3-none-any.whl

smartpipe/models/gemini_native.py

@@ -0,0 +1,196 @@
+"""Gemini's native ``:generateContent`` wire (D34) — the only endpoint that
+watches video.
+
+Chat rides here (the compat shim carries text/images/audio but not video);
+embeddings stay on the compat wire. Same taxonomy as every adapter: 401/403 →
+key screen, 404 → model-missing at first sight (D18), schema 400 → the schema
+screen, 429/5xx retried with ``Retry-After`` honored. Our JSON Schema subset is
+translated to Gemini's response schema dialect; ``validate_and_coerce`` stays
+the client-side backstop.
+"""
+
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, assert_never
+
+import httpx
+
+from smartpipe.cli import screens
+from smartpipe.core.errors import ItemError, SetupFault
+from smartpipe.core.jsontools import as_items, as_record, as_str
+from smartpipe.io import metering
+from smartpipe.models.base import AudioData, ImageData, VideoData
+from smartpipe.models.http_support import is_retryable_http, retry_after_seconds
+from smartpipe.models.openai_compat import GEMINI_WIRE, resolve_base_url
+from smartpipe.models.retry import RetryPolicy, with_retries
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from smartpipe.models.base import CompletionRequest, ModelRef
+
+__all__ = ["GeminiNativeChatModel", "native_base_url", "to_gemini_schema"]
+
+
+def native_base_url(env: Mapping[str, str]) -> str:
+    """The native root sits one path segment above the OpenAI-compat root."""
+    return resolve_base_url(env, GEMINI_WIRE).removesuffix("/openai")
+
+
+@dataclass(frozen=True, slots=True)
+class GeminiNativeChatModel:
+    ref: ModelRef
+    client: httpx.AsyncClient
+    base_url: str  # the native root (…/v1beta)
+    api_key: str
+    retry: RetryPolicy = field(default_factory=RetryPolicy)
+
+    async def complete(self, request: CompletionRequest) -> str:
+        payload: dict[str, object] = {"contents": [{"role": "user", "parts": _parts(request)}]}
+        if request.system is not None:
+            payload["systemInstruction"] = {"parts": [{"text": request.system}]}
+        # NB: gemini-2.5 rejects presence/frequency penalties outright
+        # ("Penalty is not enabled") — the anti-rambling fields are ollama-only (D35)
+        config: dict[str, object] = {
+            "maxOutputTokens": request.max_tokens,
+            "temperature": request.temperature,
+        }
+        if request.json_schema is not None:
+            config["responseMimeType"] = "application/json"
+            config["responseSchema"] = to_gemini_schema(request.json_schema)
+        payload["generationConfig"] = config
+        metering.add_request_media(request.media)
+        data = await self._post(payload)
+        record = as_record(data)
+        candidates = as_items(record.get("candidates")) if record is not None else None
+        content = as_record(candidates[0]) if candidates else None
+        inner = as_record(content.get("content")) if content is not None else None
+        parts = as_items(inner.get("parts")) if inner is not None else None
+        if parts is None:
+            raise ItemError("gemini returned an unexpected reply shape")
+        texts = [
+            text
+            for part in parts
+            if (entry := as_record(part)) is not None
+            and (text := as_str(entry.get("text"))) is not None
+        ]
+        if not texts:
+            raise ItemError("gemini returned an unexpected reply shape")
+        usage = as_record(record.get("usageMetadata")) if record is not None else None
+        if usage is not None:
+            tokens_in = usage.get("promptTokenCount")
+            tokens_out = usage.get("candidatesTokenCount")
+            metering.add_tokens(
+                tokens_in=tokens_in if isinstance(tokens_in, int) else 0,
+                tokens_out=tokens_out if isinstance(tokens_out, int) else 0,
+            )
+        return "".join(texts)
+
+    async def _post(self, payload: Mapping[str, object]) -> object:
+        url = f"{self.base_url}/models/{self.ref.name}:generateContent"
+        headers = {"x-goog-api-key": self.api_key}
+
+        async def attempt() -> object:
+            response = await self.client.post(url, json=payload, headers=headers)
+            response.raise_for_status()
+            return response.json()
+
+        try:
+            return await with_retries(
+                self.retry, attempt, is_retryable=is_retryable_http, delay_hint=retry_after_seconds
+            )
+        except httpx.HTTPStatusError as exc:
+            status = exc.response.status_code
+            if status in (401, 403):
+                raise SetupFault(
+                    f"error: the API key for '{self.ref.name}' was rejected ({status})\n"
+                    f"  The endpoint answered, but it didn't accept {GEMINI_WIRE.key_env}.\n"
+                    f"  Fix: check the key, or the endpoint in {GEMINI_WIRE.base_url_env}."
+                ) from exc
+            detail = _detail(exc.response)
+            # D18: failures that doom every item identically stop at the first
+            if status == 404:
+                raise SetupFault(
+                    screens.cloud_model_missing(self.ref.name, _host(self.base_url))
+                ) from exc
+            if status == 400 and ("responseSchema" in detail or "response_schema" in detail):
+                raise SetupFault(screens.schema_rejected(_host(self.base_url), detail)) from exc
+            raise ItemError(f"gemini error {status}: {detail}") from exc
+        except (httpx.ConnectError, httpx.ConnectTimeout) as exc:
+            raise SetupFault(
+                f"error: can't reach {self.base_url} ({exc})\n"
+                f"  The model '{self.ref}' needs that endpoint.\n"
+                f"  Check your network, or {GEMINI_WIRE.base_url_env} if you pointed "
+                "smartpipe elsewhere."
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise ItemError(f"request to {self.base_url} failed: {exc}") from exc
+
+
+def _parts(request: CompletionRequest) -> list[dict[str, object]]:
+    parts: list[dict[str, object]] = [{"text": request.user}]
+    for part in request.media:
+        match part:
+            case ImageData() | AudioData() | VideoData():
+                parts.append(
+                    {
+                        "inline_data": {
+                            "mime_type": part.mime,
+                            "data": base64.b64encode(part.data).decode("ascii"),
+                        }
+                    }
+                )
+            case _ as unreachable:  # pragma: no cover — pyright proves exhaustiveness
+                assert_never(unreachable)
+    return parts
+
+
+_SCHEMA_KEYS = ("type", "properties", "required", "items", "enum", "description")
+
+
+def to_gemini_schema(schema: Mapping[str, object]) -> dict[str, object]:
+    """Our JSON Schema subset → Gemini's response-schema dialect: the shared
+    keys carry over (types uppercased), everything else is dropped —
+    ``validate_and_coerce`` remains the real guarantee."""
+    translated: dict[str, object] = {}
+    for key in _SCHEMA_KEYS:
+        value = schema.get(key)
+        if value is None:
+            continue
+        if key == "type" and isinstance(value, str):
+            translated["type"] = value.upper()
+        elif key == "properties":
+            record = as_record(value)
+            if record is not None:
+                translated["properties"] = {
+                    name: to_gemini_schema(narrowed)
+                    for name in record
+                    if (narrowed := as_record(record.get(name))) is not None
+                }
+        elif key == "items":
+            child = as_record(value)
+            if child is not None:
+                translated["items"] = to_gemini_schema(child)
+        else:
+            translated[key] = value
+    return translated
+
+
+def _detail(response: httpx.Response) -> str:
+    record = as_record(_safe_json(response))
+    error = as_record(record.get("error")) if record is not None else None
+    message = as_str(error.get("message")) if error is not None else None
+    return message or response.text[:200]
+
+
+def _safe_json(response: httpx.Response) -> object:
+    try:
+        return response.json()
+    except ValueError:
+        return None
+
+
+def _host(base_url: str) -> str:
+    return httpx.URL(base_url).host or base_url

smartpipe/models/http_support.py

@@ -0,0 +1,77 @@
+"""Shared HTTP plumbing for provider adapters.
+
+httpx stays a function-local import: this module sits on the ``container`` path,
+and ``--help`` must never pay for the HTTP stack (tests/test_startup_imports.py
+is the gate).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    import httpx
+
+__all__ = ["default_timeout", "is_retryable_http", "make_client", "retry_after_seconds"]
+
+
+def default_timeout() -> httpx.Timeout:
+    """Generous read timeout — local models can take a while per item (plan/architecture.md)."""
+    import httpx
+
+    return httpx.Timeout(connect=5.0, read=120.0, write=30.0, pool=5.0)
+
+
+def make_client() -> httpx.AsyncClient:
+    import httpx
+
+    return httpx.AsyncClient(timeout=default_timeout())
+
+
+def retry_after_seconds(exc: Exception, *, now: Callable[[], float] = time.time) -> float | None:
+    """Seconds the server asked us to wait, from a ``Retry-After`` header.
+
+    Accepts both wire forms (integer seconds and HTTP-date); anything absent,
+    unparseable, or in the past is ``None`` — the caller falls back to its own
+    backoff. Clamping hostile values is the retry loop's job, not the parser's.
+    """
+    import httpx
+
+    if not isinstance(exc, httpx.HTTPStatusError):
+        return None
+    header = exc.response.headers.get("retry-after")
+    if header is None:
+        return None
+    text = header.strip()
+    if text.isdigit():  # RFC 7231 delay-seconds is non-negative; "-5" falls through
+        return float(text)
+    from email.utils import parsedate_to_datetime
+
+    try:
+        target = parsedate_to_datetime(text)
+    except (TypeError, ValueError):
+        return None
+    if target.tzinfo is None:  # RFC 7231 dates are GMT; a bare date reads as UTC
+        from datetime import UTC
+
+        target = target.replace(tzinfo=UTC)
+    delta = target.timestamp() - now()
+    return delta if delta >= 0 else None
+
+
+def is_retryable_http(exc: Exception) -> bool:
+    import httpx
+
+    if isinstance(exc, httpx.HTTPStatusError):
+        status = exc.response.status_code
+        return status == 429 or status >= 500
+    # TimeoutException is the shared base of ConnectTimeout/ReadTimeout/
+    # WriteTimeout/PoolTimeout — keying off it catches all four (the connect and
+    # write variants are NOT subclasses of ConnectError/WriteError in httpx).
+    return isinstance(
+        exc,
+        httpx.TimeoutException | httpx.ConnectError | httpx.RemoteProtocolError | httpx.WriteError,
+    )

smartpipe/models/jina.py

@@ -0,0 +1,98 @@
+"""The Jina embeddings wire (D39/04): text AND images in one space.
+
+jina-clip-v2 is the first media-native embedder — mentioning it
+(``--embed-model jina/jina-clip-v2``) switches image items away from the
+caption pivot. Same endpoint shape as the compat wire, plus image entries.
+"""
+
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import httpx
+
+from smartpipe.core.errors import ItemError, SetupFault
+from smartpipe.core.jsontools import as_float_vector, as_items, as_record
+from smartpipe.io import metering
+from smartpipe.models.base import ImageData
+from smartpipe.models.http_support import is_retryable_http, retry_after_seconds
+from smartpipe.models.retry import RetryPolicy, with_retries
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from smartpipe.models.base import ModelRef
+
+__all__ = ["JINA_BASE_URL", "JinaClipEmbeddingModel"]
+
+JINA_BASE_URL = "https://api.jina.ai"
+
+
+@dataclass(frozen=True, slots=True)
+class JinaClipEmbeddingModel:
+    ref: ModelRef
+    client: httpx.AsyncClient
+    api_key: str
+    base_url: str = JINA_BASE_URL
+    retry: RetryPolicy = field(default_factory=RetryPolicy)
+
+    async def embed(self, texts: Sequence[str]) -> tuple[tuple[float, ...], ...]:
+        return await self.embed_parts(list(texts))
+
+    async def embed_parts(self, parts: Sequence[str | ImageData]) -> tuple[tuple[float, ...], ...]:
+        entries: list[dict[str, str]] = []
+        for part in parts:
+            if isinstance(part, ImageData):
+                entries.append({"image": base64.b64encode(part.data).decode("ascii")})
+            else:
+                entries.append({"text": part})
+        payload: dict[str, object] = {"model": self.ref.name, "input": entries}
+        metering.add_request_media(tuple(part for part in parts if not isinstance(part, str)))
+        data = await self._post("/v1/embeddings", payload)
+        record = as_record(data)
+        rows = as_items(record.get("data")) if record is not None else None
+        if rows is None:
+            raise ItemError("jina embedding endpoint returned an unexpected shape")
+        usage = as_record(record.get("usage")) if record is not None else None
+        if usage is not None:
+            total = usage.get("total_tokens")
+            metering.add_tokens(tokens_in=total if isinstance(total, int) else 0)
+        indexed: list[tuple[int, tuple[float, ...]]] = []
+        for position, row in enumerate(rows):
+            entry = as_record(row)
+            vector = as_float_vector(entry.get("embedding")) if entry is not None else None
+            if entry is None or vector is None:
+                raise ItemError("jina embedding endpoint returned an unexpected shape")
+            index = entry.get("index")
+            indexed.append((index if isinstance(index, int) else position, vector))
+        return tuple(vector for _index, vector in sorted(indexed))
+
+    async def _post(self, path: str, payload: dict[str, object]) -> object:
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        async def attempt() -> object:
+            response = await self.client.post(
+                f"{self.base_url}{path}", json=payload, headers=headers
+            )
+            response.raise_for_status()
+            return response.json()
+
+        try:
+            return await with_retries(
+                self.retry,
+                attempt,
+                is_retryable=is_retryable_http,
+                delay_hint=retry_after_seconds,
+            )
+        except httpx.HTTPStatusError as exc:
+            status = exc.response.status_code
+            if status in (401, 403):
+                raise SetupFault(
+                    "error: Jina rejected the API key\n"
+                    "  Set JINA_API_KEY (https://jina.ai) and retry."
+                ) from exc
+            raise ItemError(f"jina error {status}: {exc.response.text[:200]}") from exc
+        except httpx.HTTPError as exc:
+            raise ItemError(f"jina request failed ({exc})") from exc

smartpipe/models/local_embed.py

@@ -0,0 +1,76 @@
+"""The local embedding wire (D44): pure Python, no server, no key.
+
+fastembed runs nomic-embed-text v1.5 as ONNX on CPU. This is the DEFAULT
+embedder: `smartpipe embed` works on a fresh install with nothing running.
+The model (~130 MB) downloads once on first use, disclosed. Imports stay
+inside methods — the startup budget never pays for onnxruntime. ONE engine
+per model instance, loaded lazily and reused for every batch; the container
+hands verbs a single instance per run, and weights cache on disk across runs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from smartpipe.core.errors import ItemError
+from smartpipe.io import diagnostics
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from smartpipe.models.base import ModelRef
+
+__all__ = ["LOCAL_EMBED_MODEL", "LocalEmbeddingModel"]
+
+LOCAL_EMBED_MODEL = "nomic-ai/nomic-embed-text-v1.5"
+
+_announced = False  # the one-time download note, once per process
+
+
+def _plain(vector: object) -> object:
+    """numpy arrays expose tolist(); plain sequences pass through untouched."""
+    lister = getattr(vector, "tolist", None)
+    return lister() if callable(lister) else vector
+
+
+@dataclass(slots=True)
+class LocalEmbeddingModel:
+    ref: ModelRef
+    engine: object | None = field(default=None, repr=False)  # injected in tests; lazy-loaded live
+
+    async def embed(self, texts: Sequence[str]) -> tuple[tuple[float, ...], ...]:
+        return await asyncio.to_thread(self._embed_blocking, list(texts))
+
+    def _embed_blocking(self, texts: list[str]) -> tuple[tuple[float, ...], ...]:
+        from smartpipe.core.jsontools import as_float_vector
+
+        engine = self._load()
+        try:
+            produced: list[object] = list(engine.embed(texts))  # type: ignore[attr-defined]
+        except Exception as exc:  # onnx failures become per-item errors
+            raise ItemError(f"local embedding failed ({exc})") from exc
+        vectors: list[tuple[float, ...]] = []
+        for entry in produced:
+            vector = as_float_vector(_plain(entry))
+            if vector is None:
+                raise ItemError("the local embedder returned an unexpected shape")
+            vectors.append(vector)
+        return tuple(vectors)
+
+    def _load(self) -> object:
+        if self.engine is not None:
+            return self.engine  # loaded once, reused for every batch
+        global _announced
+        if not _announced:
+            _announced = True
+            diagnostics.note(
+                "local embeddings: nomic-embed-text v1.5 on CPU (first use downloads ~130 MB, once)"
+            )
+        try:
+            from fastembed import TextEmbedding
+        except ImportError as exc:  # pragma: no cover — fastembed is a core dep
+            raise ItemError("the local embedder is unavailable — reinstall smartpipe") from exc
+        self.engine = TextEmbedding(model_name=LOCAL_EMBED_MODEL)
+        return self.engine

smartpipe/models/ollama.py

@@ -0,0 +1,204 @@
+"""The local-first default provider (plan/architecture.md adapter table).
+
+Failure philosophy: a refused connection or a missing model fails *fast* with a
+screen that names the fix (a local daemon being down is a setup problem, not a
+transient blip); 429/5xx/timeouts are retried, then skip just that item.
+"""
+
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import httpx
+
+from smartpipe.cli import screens
+from smartpipe.core.errors import ItemError, SetupFault
+from smartpipe.core.jsontools import as_float_vector, as_items, as_record, as_str, record_at
+from smartpipe.io import metering
+from smartpipe.models.base import AudioData, ImageData, VideoData
+from smartpipe.models.http_support import is_retryable_http, retry_after_seconds
+from smartpipe.models.retry import RetryPolicy, with_retries
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from smartpipe.models.base import CompletionRequest, ModelRef
+
+_NO_VISION = "model can't read images — try a vision model, e.g. --model ollama/qwen3-vl"
+
+__all__ = [
+    "DEFAULT_HOST",
+    "OllamaChatModel",
+    "OllamaEmbeddingModel",
+    "ollama_model_names",
+    "resolve_host",
+]
+
+DEFAULT_HOST = "http://localhost:11434"
+
+
+def resolve_host(env: Mapping[str, str]) -> str:
+    host = env.get("OLLAMA_HOST", "").strip() or DEFAULT_HOST
+    if "://" not in host:  # OLLAMA_HOST convention allows bare host:port
+        host = f"http://{host}"
+    return host.rstrip("/")
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaChatModel:
+    ref: ModelRef
+    client: httpx.AsyncClient
+    host: str
+    retry: RetryPolicy = field(default_factory=RetryPolicy)
+
+    async def complete(self, request: CompletionRequest) -> str:
+        messages: list[dict[str, object]] = []
+        if request.system is not None:
+            messages.append({"role": "system", "content": request.system})
+        user: dict[str, object] = {"role": "user", "content": request.user}
+        if any(isinstance(part, VideoData) for part in request.media):
+            raise ItemError(
+                "this model can't watch video — map converts it to frames + audio "
+                "automatically (gemini watches natively)"
+            )
+        if any(isinstance(part, AudioData) for part in request.media):
+            # ollama's chat API carries images only — fail before any bytes leave (D20 §2)
+            raise ItemError(
+                "this model can't hear audio — try an audio model "
+                "(voxtral, gemini) — smartpipe transcribes locally otherwise"
+            )
+        images = [part for part in request.media if isinstance(part, ImageData)]
+        if images:
+            user["images"] = [base64.b64encode(image.data).decode() for image in images]
+        messages.append(user)
+        options: dict[str, object] = {
+            "num_predict": request.max_tokens,
+            "temperature": request.temperature,
+        }
+        if request.presence_penalty is not None:
+            options["presence_penalty"] = request.presence_penalty
+        if request.frequency_penalty is not None:
+            options["frequency_penalty"] = request.frequency_penalty
+        payload: dict[str, object] = {
+            "model": self.ref.name,
+            "stream": False,
+            "messages": messages,
+            "options": options,  # tiny local models ramble unbounded otherwise (D35)
+        }
+        if request.json_schema is not None:
+            payload["format"] = dict(request.json_schema)
+        metering.add_request_media(request.media)
+        try:
+            data = await _post(self, "/api/chat", payload)
+        except ItemError as exc:
+            # _post maps a 400 to ItemError; with images in flight that almost
+            # always means "this model has no vision" — say so, name a fix.
+            if request.media and "error 400" in str(exc):
+                raise ItemError(_NO_VISION) from exc
+            raise
+        message = record_at(data, "message")
+        content = as_str(message.get("content")) if message is not None else None
+        if content is None:
+            raise ItemError("ollama returned an unexpected reply shape")
+        _meter_usage(data)
+        return content
+
+
+@dataclass(frozen=True, slots=True)
+class OllamaEmbeddingModel:
+    ref: ModelRef
+    client: httpx.AsyncClient
+    host: str
+    retry: RetryPolicy = field(default_factory=RetryPolicy)
+
+    async def embed(self, texts: Sequence[str]) -> tuple[tuple[float, ...], ...]:
+        payload: dict[str, object] = {"model": self.ref.name, "input": list(texts)}
+        data = await _post(self, "/api/embed", payload)
+        record = as_record(data)
+        rows = as_items(record.get("embeddings")) if record is not None else None
+        if rows is None:
+            raise ItemError("ollama returned an unexpected embeddings shape")
+        vectors: list[tuple[float, ...]] = []
+        for row in rows:
+            vector = as_float_vector(row)
+            if vector is None:
+                raise ItemError("ollama returned an unexpected embeddings shape")
+            vectors.append(vector)
+        return tuple(vectors)
+
+
+async def ollama_model_names(client: httpx.AsyncClient, host: str) -> tuple[str, ...] | None:
+    """Installed model names, or None when no Ollama is listening (a probe, never fatal)."""
+    try:
+        response = await client.get(f"{host}/api/tags", timeout=2.0)
+        response.raise_for_status()
+    except httpx.HTTPError:
+        return None
+    models = as_record(response.json())
+    entries = as_items(models.get("models")) if models is not None else None
+    if entries is None:
+        return None
+    names: list[str] = []
+    for entry in entries:
+        record = as_record(entry)
+        name = as_str(record.get("name")) if record is not None else None
+        if name is not None:
+            names.append(name)
+    return tuple(names)
+
+
+async def _post(
+    model: OllamaChatModel | OllamaEmbeddingModel, path: str, payload: Mapping[str, object]
+) -> object:
+    async def attempt() -> object:
+        try:
+            response = await model.client.post(f"{model.host}{path}", json=payload)
+        except (httpx.ConnectError, httpx.ConnectTimeout) as exc:
+            # A local daemon that's down or wedged is a setup problem: fail fast
+            # with the fix screen rather than retrying (ConnectTimeout is a
+            # TimeoutException, so it must be named explicitly here).
+            timed_out = isinstance(exc, httpx.ConnectTimeout)
+            reason = "connection timed out" if timed_out else "connection refused"
+            raise SetupFault(
+                screens.ollama_unreachable(model.host, str(model.ref), reason)
+            ) from exc
+        if response.status_code == 404:
+            detail = _error_detail(response)
+            raise SetupFault(screens.ollama_model_missing(model.ref.name, model.host, detail))
+        response.raise_for_status()
+        return response.json()
+
+    try:
+        return await with_retries(
+            model.retry, attempt, is_retryable=is_retryable_http, delay_hint=retry_after_seconds
+        )
+    except httpx.HTTPStatusError as exc:
+        detail = _error_detail(exc.response)
+        raise ItemError(f"ollama error {exc.response.status_code}: {detail}") from exc
+    except httpx.HTTPError as exc:
+        raise ItemError(f"ollama request failed: {exc}") from exc
+
+
+def _error_detail(response: httpx.Response) -> str:
+    try:
+        record = as_record(response.json())
+    except ValueError:
+        record = None
+    detail = as_str(record.get("error")) if record is not None else None
+    return detail if detail is not None else response.text[:200].strip() or "no detail"
+
+
+def _meter_usage(data: object) -> None:
+    from smartpipe.core.jsontools import as_record
+
+    record = as_record(data)
+    if record is None:
+        return
+    tokens_in = record.get("prompt_eval_count")
+    tokens_out = record.get("eval_count")
+    metering.add_tokens(
+        tokens_in=tokens_in if isinstance(tokens_in, int) else 0,
+        tokens_out=tokens_out if isinstance(tokens_out, int) else 0,
+    )