prompture 1.9.1.dev1__tar.gz → 1.9.1.dev2__tar.gz

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.9.1.dev1
+Version: 1.9.1.dev2
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.9.1.dev1'
-__version_tuple__ = version_tuple = (1, 9, 1, 'dev1')
+__version__ = version = '1.9.1.dev2'
+__version_tuple__ = version_tuple = (1, 9, 1, 'dev2')
 
 __commit_id__ = commit_id = None

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/agents/agent.py

@@ -133,7 +133,9 @@ def _get_first_param_name(fn: Callable[..., Any]) -> str:
     return ""
 
 
-def _parse_simulated_tool_call(content: str) -> tuple[str, dict[str, Any]] | None:
+def _parse_simulated_tool_call(
+    content: str, known_tools: Any | None = None
+) -> tuple[str, dict[str, Any]] | None:
     """Recognise a prompted (simulated) tool call recorded as assistant text.
 
     Drivers without ``supports_tool_use`` go through
@@ -154,10 +156,17 @@ def _parse_simulated_tool_call(content: str) -> tuple[str, dict[str, Any]] | Non
         return None
     if not isinstance(obj, dict):
         return None
-    # Explicit discriminator, or the inferred shape parse_simulated_response
-    # also accepts when the model omits "type".
-    if obj.get("type") != "tool_call" and not ("name" in obj and "arguments" in obj):
-        return None
+    if obj.get("type") != "tool_call":
+        # Inferred shape (no discriminator), which parse_simulated_response
+        # also accepts when the model omits "type".
+        if not ("name" in obj and "arguments" in obj):
+            return None
+        # A structured ANSWER can legitimately carry name+arguments keys (a
+        # schema echo, a function description). When the caller can tell us
+        # which tools exist, only reclassify when the name matches one —
+        # otherwise the model's final output would silently vanish.
+        if known_tools is not None and obj.get("name") not in known_tools:
+            return None
     name = obj.get("name")
     args = obj.get("arguments", {})
     if not isinstance(name, str) or not name or not isinstance(args, dict):
@@ -1176,7 +1185,9 @@ class Agent(Generic[DepsType]):
                         )
                         all_tool_calls.append({"name": name, "arguments": args, "id": tc.get("id", "")})
                 else:
-                    simulated = _parse_simulated_tool_call(content)
+                    simulated = _parse_simulated_tool_call(
+                        content, known_tools=(self._tools.names if self._tools else None)
+                    )
                     if simulated is not None:
                         # Prompted tool call: same step shape as the native path
                         # so a host sees one run, not two dialects.

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/agents/assistant.py

@@ -384,13 +384,25 @@ class Assistant:
     ) -> AssistantResult:
         agent = self._build_async_agent(call_vars=call_vars)
         result: AgentResult = await agent.run(prompt, deps=deps)
+        # AgentResult.usage is a DICT (prompt_tokens/completion_tokens/cost) —
+        # getattr on a dict returns the default, so the attribute-style reads
+        # left cost_usd/input_tokens/output_tokens permanently None on the LLM
+        # backend and every host that trusted them recorded $0.00 forever.
         usage = getattr(result, "usage", None)
+        if isinstance(usage, dict):
+            cost_usd = usage.get("cost")
+            input_tokens = usage.get("prompt_tokens")
+            output_tokens = usage.get("completion_tokens")
+        else:
+            cost_usd = getattr(usage, "total_cost_usd", None) if usage else None
+            input_tokens = getattr(usage, "input_tokens", None) if usage else None
+            output_tokens = getattr(usage, "output_tokens", None) if usage else None
         return AssistantResult(
             output=getattr(result, "output", "") or "",
             backend="llm",
-            cost_usd=getattr(usage, "total_cost_usd", None) if usage else None,
-            input_tokens=getattr(usage, "input_tokens", None) if usage else None,
-            output_tokens=getattr(usage, "output_tokens", None) if usage else None,
+            cost_usd=cost_usd,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
             session_id=None,
             raw=result,
         )

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/agents/async_agent.py

@@ -56,7 +56,7 @@ _DEFAULT_MAX_AGENT_DEPTH = 5
 
 # Share the same ContextVar with the sync Agent so depth tracking crosses
 # agent boundaries (e.g. a sync Agent calling an AsyncAgent as a tool).
-from .agent import _agent_depth
+from .agent import _agent_depth, _parse_simulated_tool_call
 
 # ------------------------------------------------------------------
 # Helpers
@@ -1150,8 +1150,15 @@ class AsyncAgent(Generic[DepsType]):
         for rec in tool_timings or []:
             timings_by_name.setdefault(rec.get("name", ""), []).append(rec)
 
+        # Name of a simulated tool call awaiting its result, which the prompted
+        # loop records as the next user message rather than a "tool" message.
+        pending_sim_tool: str | None = None
+
         for msg in messages:
             role = msg.get("role", "")
+            # Claim (and clear) any simulated call left by the previous message.
+            sim_tool = pending_sim_tool
+            pending_sim_tool = None
             # Extract usage from message meta if present
             msg_meta = msg.get("meta")
             step_usage = None
@@ -1204,14 +1211,45 @@ class AsyncAgent(Generic[DepsType]):
                         )
                         all_tool_calls.append({"name": name, "arguments": args, "id": tc.get("id", "")})
                 else:
-                    steps.append(
-                        AgentStep(
-                            step_type=StepType.output,
-                            timestamp=now,
-                            content=content,
-                            usage=step_usage,
+                    simulated = _parse_simulated_tool_call(
+                        content, known_tools=(self._tools.names if self._tools else None)
+                    )
+                    if simulated is not None:
+                        # Prompted tool call: same step shape as the native path
+                        # so a host sees one run, not two dialects.
+                        sim_name, sim_args = simulated
+                        steps.append(
+                            AgentStep(
+                                step_type=StepType.tool_call,
+                                timestamp=now,
+                                content="",
+                                tool_name=sim_name,
+                                tool_args=sim_args,
+                                usage=step_usage,
+                            )
                         )
+                        all_tool_calls.append({"name": sim_name, "arguments": sim_args, "id": ""})
+                        pending_sim_tool = sim_name
+                    else:
+                        steps.append(
+                            AgentStep(
+                                step_type=StepType.output,
+                                timestamp=now,
+                                content=content,
+                                usage=step_usage,
+                            )
+                        )
+
+            elif role == "user" and sim_tool is not None:
+                # The prompted loop stores a tool result as a user message.
+                steps.append(
+                    AgentStep(
+                        step_type=StepType.tool_result,
+                        timestamp=now,
+                        content=msg.get("content", "") or "",
+                        tool_name=sim_tool,
                     )
+                )
 
             elif role == "tool":
                 tool_call_id = msg.get("tool_call_id")

prompture-1.9.1.dev2/prompture/drivers/_media_usage.py

@@ -0,0 +1,118 @@
+"""Shared usage recording for media driver hook wrappers.
+
+Media calls bill per image / second / job rather than per token, so the text
+drivers' ``_auto_record_usage`` doesn't fit — but the spend is just as real,
+and until this helper existed it never reached the usage tracker: media cost
+lived only on the immediate response ``meta`` and vanished unless the caller
+kept it. Every media ``*_with_hooks`` wrapper now records one
+:class:`~prompture.infra.tracker.UsageEvent` (zero tokens, ``cost`` from meta,
+unit count in ``metadata``) through the same global tracker as text calls, so
+sinks and the SQLite ledger see the whole picture.
+
+Fire-and-forget, mirroring the text bases: recording must never break the
+generation it measures.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def record_embedding_driver_usage(
+    driver: Any,
+    meta: dict[str, Any] | None,
+    elapsed_ms: float,
+    *,
+    text_count: int,
+    status: str = "success",
+    error: Exception | None = None,
+) -> None:
+    """Record one embedding call as a usage event. Never raises.
+
+    Embeddings are input-only, so the token count lands on both
+    ``prompt_tokens`` and ``total_tokens``.
+    """
+    try:
+        from ..infra.ledger import _resolve_api_key_hash
+        from ..infra.tracker import UsageEvent, get_tracker
+
+        tracker = get_tracker()
+        if not tracker._enabled:
+            return
+
+        meta = meta or {}
+        driver_name = str(meta.get("model_name") or getattr(driver, "model", driver.__class__.__name__))
+
+        if "/" in driver_name:
+            provider, model = driver_name.split("/", 1)
+        else:
+            cls_name = driver.__class__.__name__.removeprefix("Async")
+            provider = cls_name.removesuffix("Driver").lower()
+            model = driver_name
+
+        model_name = f"{provider}/{model}" if provider else model
+        tokens = int(meta.get("total_tokens") or 0)
+
+        event = UsageEvent(
+            model_name=model_name,
+            provider=provider,
+            api_key_hash=_resolve_api_key_hash(model_name),
+            prompt_tokens=tokens,
+            total_tokens=tokens,
+            cost=float(meta.get("cost") or 0.0),
+            elapsed_ms=elapsed_ms,
+            status=status,
+            error_type=type(error).__name__ if error else None,
+            metadata={"modality": "embedding", "count": text_count},
+        )
+        tracker.record(event)
+    except Exception:
+        pass  # fire-and-forget
+
+
+def record_media_usage(
+    driver: Any,
+    meta: dict[str, Any] | None,
+    elapsed_ms: float,
+    *,
+    modality: str,
+    count_key: str,
+    status: str = "success",
+    error: Exception | None = None,
+) -> None:
+    """Record one media generation as a usage event. Never raises."""
+    try:
+        from ..infra.ledger import _resolve_api_key_hash
+        from ..infra.tracker import UsageEvent, get_tracker
+
+        tracker = get_tracker()
+        if not tracker._enabled:
+            return
+
+        meta = meta or {}
+        driver_name = str(meta.get("model_name") or getattr(driver, "model", driver.__class__.__name__))
+
+        if "/" in driver_name:
+            provider, model = driver_name.split("/", 1)
+        else:
+            # Same class-name fallback as the text bases, Async prefix stripped
+            # so async twins attribute to the same provider.
+            cls_name = driver.__class__.__name__.removeprefix("Async")
+            provider = cls_name.removesuffix("Driver").lower()
+            model = driver_name
+
+        model_name = f"{provider}/{model}" if provider else model
+
+        event = UsageEvent(
+            model_name=model_name,
+            provider=provider,
+            api_key_hash=_resolve_api_key_hash(model_name),
+            cost=float(meta.get("cost") or 0.0),
+            elapsed_ms=elapsed_ms,
+            status=status,
+            error_type=type(error).__name__ if error else None,
+            metadata={"modality": modality, "count": int(meta.get(count_key) or 0)},
+        )
+        tracker.record(event)
+    except Exception:
+        pass  # fire-and-forget

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/aggregator_base.py

@@ -194,7 +194,12 @@ class AggregatorClient:
         return file_url
 
     # ── Job handle / resume ──
-    def _make_handle(self, slug: str, request_id: str, modality: str) -> JobHandle:
+    def _make_handle(
+        self, slug: str, request_id: str, modality: str, *, pricing: dict[str, Any] | None = None
+    ) -> JobHandle:
+        # `pricing` captures the quote inputs (n / duration / resolution) at
+        # submit time, so a resume from another process can still price the
+        # job — the provider result carries none of them.
         return JobHandle(
             task_id=request_id,
             provider=self.PROVIDER,
@@ -204,6 +209,7 @@ class AggregatorClient:
             endpoint=self.endpoint,
             polling_url=self.result_url(request_id),
             submitted_at=time.time(),
+            extra={"pricing": pricing} if pricing else {},
         )
 
     def get_job_status(self, handle: JobHandle) -> str:
@@ -229,11 +235,23 @@ class AggregatorClient:
             MediaAsset(kind=kind, url=u, model=handle.model, provenance={"request_id": handle.task_id})
             for u in self.extract_urls(raw)
         ]
+        meta: dict[str, Any] = {"request_id": handle.task_id, "model_name": f"{self.PROVIDER}/{handle.model}"}
+        if status == JobStatus.COMPLETED.value:
+            # Price from the quote inputs captured at submit time (handle.extra)
+            # — without this, every async job reported zero cost at every
+            # stage of its lifecycle.
+            pricing = (handle.extra or {}).get("pricing") or {}
+            meta["cost"] = self._media_cost(
+                handle.model,
+                n=int(pricing.get("n") or max(len(assets), 1)),
+                duration_seconds=float(pricing.get("duration_seconds") or 0.0),
+                resolution=pricing.get("resolution"),
+            )
         return JobResult(
             handle=handle.with_status(status),
             status=status,
             assets=assets,
-            meta={"request_id": handle.task_id, "model_name": f"{self.PROVIDER}/{handle.model}"},
+            meta=meta,
             raw=raw,
         )
 
@@ -250,6 +268,32 @@ class AggregatorClient:
             resolution=resolution,
         )
 
+    def _effective_duration(self, slug: str, options: dict[str, Any]) -> float:
+        """The duration the provider will actually bill for.
+
+        An explicit ``duration`` option wins; otherwise the model's declared
+        capability default — the provider runs its default clip length and
+        bills for it whether or not the caller passed the option, so pricing
+        with 0 was quoting $0 for real spend.
+        """
+        raw = options.get("duration")
+        if raw:
+            try:
+                return float(raw)
+            except (TypeError, ValueError):
+                pass
+        try:
+            from .media_capabilities import get_model_schema
+
+            info = get_model_schema(f"{self.PROVIDER}/{slug}")
+            spec = (info.inputs or {}).get("duration") if info else None
+            default = getattr(spec, "default", None)
+            if default:
+                return float(default)
+        except Exception:
+            pass
+        return 0.0
+
     # ── Media input resolution (for conditioned ops: i2i / i2v / lipsync) ──
     def _coerce_media_url(self, source: Any, *, explicit: str | None = None, filename: str = "input.bin") -> str | None:
         """Resolve a media input to a hosted URL.
@@ -321,7 +365,9 @@ class AggregatorImageDriver(AggregatorClient, ImageGenDriver):
     def _pending_image(
         self, slug: str, request_id: str, submitted: dict[str, Any], options: dict[str, Any]
     ) -> dict[str, Any]:
-        handle = self._make_handle(slug, request_id, "image")
+        handle = self._make_handle(
+            slug, request_id, "image", pricing={"n": int(options.get("n") or 1)}
+        )
         return {
             "images": [],
             "meta": {
@@ -399,9 +445,13 @@ class AggregatorVideoDriver(AggregatorClient, VideoGenDriver):
         slug = options.get("model", self.model)
         payload = self.build_video_payload(prompt, options)
         request_id, submitted = self._submit(slug, payload)
+        duration = self._effective_duration(slug, options)
 
         if request_id is not None and not options.get("poll", True):
-            handle = self._make_handle(slug, request_id, "video")
+            handle = self._make_handle(
+                slug, request_id, "video",
+                pricing={"n": 1, "duration_seconds": duration, "resolution": options.get("resolution")},
+            )
             return {
                 "videos": [],
                 "meta": {
@@ -428,7 +478,6 @@ class AggregatorVideoDriver(AggregatorClient, VideoGenDriver):
             )
         )
         videos = [video_from_url(u) for u in self.extract_urls(result)]
-        duration = float(options.get("duration", 0) or 0)
         cost = self._media_cost(slug, n=1, duration_seconds=duration, resolution=options.get("resolution"))
         return {
             "videos": videos,
@@ -509,8 +558,12 @@ class AggregatorLipsyncDriver(AggregatorClient, LipsyncDriver):
         payload = self.build_lipsync_payload(options, audio_url=audio_url, image_url=image_url, video_url=video_url)
 
         request_id, submitted = self._submit(slug, payload)
+        duration = self._effective_duration(slug, options)
         if request_id is not None and not options.get("poll", True):
-            handle = self._make_handle(slug, request_id, "lipsync")
+            handle = self._make_handle(
+                slug, request_id, "lipsync",
+                pricing={"n": 1, "duration_seconds": duration},
+            )
             return {
                 "videos": [],
                 "meta": {
@@ -535,7 +588,6 @@ class AggregatorLipsyncDriver(AggregatorClient, LipsyncDriver):
             )
         )
         videos = [video_from_url(u) for u in self.extract_urls(result)]
-        duration = float(options.get("duration", 0) or 0)
         cost = self._media_cost(slug, n=1, duration_seconds=duration)
         return {
             "videos": videos,
@@ -604,7 +656,7 @@ class AggregatorMusicDriver(AggregatorClient, MusicGenDriver):
         request_id, submitted = self._submit(slug, payload)
 
         if request_id is not None and not options.get("poll", True):
-            handle = self._make_handle(slug, request_id, "music")
+            handle = self._make_handle(slug, request_id, "music", pricing={"n": 1})
             return {
                 "audio": [],
                 "meta": {

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/async_aggregator_base.py

@@ -149,7 +149,12 @@ class AsyncAggregatorClient:
             raise RuntimeError(f"{self.PROVIDER} upload returned no URL: {dj}")
         return file_url
 
-    def _make_handle(self, slug: str, request_id: str, modality: str) -> JobHandle:
+    def _make_handle(
+        self, slug: str, request_id: str, modality: str, *, pricing: dict[str, Any] | None = None
+    ) -> JobHandle:
+        # `pricing` captures the quote inputs (n / duration / resolution) at
+        # submit time, so a resume from another process can still price the
+        # job — the provider result carries none of them.
         return JobHandle(
             task_id=request_id,
             provider=self.PROVIDER,
@@ -159,6 +164,7 @@ class AsyncAggregatorClient:
             endpoint=self.endpoint,
             polling_url=self.result_url(request_id),
             submitted_at=time.time(),
+            extra={"pricing": pricing} if pricing else {},
         )
 
     async def get_job_status(self, handle: JobHandle) -> str:
@@ -187,11 +193,23 @@ class AsyncAggregatorClient:
             MediaAsset(kind=kind, url=u, model=handle.model, provenance={"request_id": handle.task_id})
             for u in self.extract_urls(raw)
         ]
+        meta: dict[str, Any] = {"request_id": handle.task_id, "model_name": f"{self.PROVIDER}/{handle.model}"}
+        if status == JobStatus.COMPLETED.value:
+            # Price from the quote inputs captured at submit time (handle.extra)
+            # — without this, every async job reported zero cost at every
+            # stage of its lifecycle.
+            pricing = (handle.extra or {}).get("pricing") or {}
+            meta["cost"] = self._media_cost(
+                handle.model,
+                n=int(pricing.get("n") or max(len(assets), 1)),
+                duration_seconds=float(pricing.get("duration_seconds") or 0.0),
+                resolution=pricing.get("resolution"),
+            )
         return JobResult(
             handle=handle.with_status(status),
             status=status,
             assets=assets,
-            meta={"request_id": handle.task_id, "model_name": f"{self.PROVIDER}/{handle.model}"},
+            meta=meta,
             raw=raw,
         )
 
@@ -202,6 +220,32 @@ class AsyncAggregatorClient:
 
         return estimate_media_cost(f"{self.PROVIDER}/{slug}", n=n, duration_seconds=duration_seconds, resolution=resolution)
 
+    def _effective_duration(self, slug: str, options: dict[str, Any]) -> float:
+        """The duration the provider will actually bill for.
+
+        An explicit ``duration`` option wins; otherwise the model's declared
+        capability default — the provider runs its default clip length and
+        bills for it whether or not the caller passed the option, so pricing
+        with 0 was quoting $0 for real spend.
+        """
+        raw = options.get("duration")
+        if raw:
+            try:
+                return float(raw)
+            except (TypeError, ValueError):
+                pass
+        try:
+            from .media_capabilities import get_model_schema
+
+            info = get_model_schema(f"{self.PROVIDER}/{slug}")
+            spec = (info.inputs or {}).get("duration") if info else None
+            default = getattr(spec, "default", None)
+            if default:
+                return float(default)
+        except Exception:
+            pass
+        return 0.0
+
     async def _coerce_media_url(
         self, source: Any, *, explicit: str | None = None, filename: str = "input.bin"
     ) -> str | None:
@@ -268,7 +312,9 @@ class AsyncAggregatorImageDriver(AsyncAggregatorClient, AsyncImageGenDriver):
             if request_id is None:
                 return self._finalize_image(slug, None, submitted, options)
             if not options.get("poll", True):
-                handle = self._make_handle(slug, request_id, "image")
+                handle = self._make_handle(
+                    slug, request_id, "image", pricing={"n": int(options.get("n") or 1)}
+                )
                 return {
                     "images": [],
                     "meta": {
@@ -335,10 +381,14 @@ class AsyncAggregatorVideoDriver(AsyncAggregatorClient, AsyncVideoGenDriver):
         self._require_key()
         slug = options.get("model", self.model)
         payload = self.build_video_payload(prompt, options)
+        duration = self._effective_duration(slug, options)
         async with httpx.AsyncClient(timeout=120.0) as client:
             request_id, submitted = await self._submit(client, slug, payload)
             if request_id is not None and not options.get("poll", True):
-                handle = self._make_handle(slug, request_id, "video")
+                handle = self._make_handle(
+                    slug, request_id, "video",
+                    pricing={"n": 1, "duration_seconds": duration, "resolution": options.get("resolution")},
+                )
                 return {
                     "videos": [],
                     "meta": {
@@ -365,7 +415,6 @@ class AsyncAggregatorVideoDriver(AsyncAggregatorClient, AsyncVideoGenDriver):
                 )
             )
         videos = [video_from_url(u) for u in self.extract_urls(result)]
-        duration = float(options.get("duration", 0) or 0)
         cost = self._media_cost(slug, n=1, duration_seconds=duration, resolution=options.get("resolution"))
         return {
             "videos": videos,
@@ -441,10 +490,14 @@ class AsyncAggregatorLipsyncDriver(AsyncAggregatorClient, AsyncLipsyncDriver):
         category = "video" if video_url else "image"
         payload = self.build_lipsync_payload(options, audio_url=audio_url, image_url=image_url, video_url=video_url)
 
+        duration = self._effective_duration(slug, options)
         async with httpx.AsyncClient(timeout=120.0) as client:
             request_id, submitted = await self._submit(client, slug, payload)
             if request_id is not None and not options.get("poll", True):
-                handle = self._make_handle(slug, request_id, "lipsync")
+                handle = self._make_handle(
+                    slug, request_id, "lipsync",
+                    pricing={"n": 1, "duration_seconds": duration},
+                )
                 return {
                     "videos": [],
                     "meta": {
@@ -469,7 +522,6 @@ class AsyncAggregatorLipsyncDriver(AsyncAggregatorClient, AsyncLipsyncDriver):
                 )
             )
         videos = [video_from_url(u) for u in self.extract_urls(result)]
-        duration = float(options.get("duration", 0) or 0)
         cost = self._media_cost(slug, n=1, duration_seconds=duration)
         return {
             "videos": videos,
@@ -534,7 +586,7 @@ class AsyncAggregatorMusicDriver(AsyncAggregatorClient, AsyncMusicGenDriver):
         async with httpx.AsyncClient(timeout=120.0) as client:
             request_id, submitted = await self._submit(client, slug, payload)
             if request_id is not None and not options.get("poll", True):
-                handle = self._make_handle(slug, request_id, "music")
+                handle = self._make_handle(slug, request_id, "music", pricing={"n": 1})
                 return {
                     "audio": [],
                     "meta": {

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/async_base.py

@@ -286,7 +286,12 @@ class AsyncDriver(ABC):
             if "/" in driver_name:
                 provider, model = driver_name.split("/", 1)
             else:
-                provider = self.__class__.__name__.replace("AsyncDriver", "").replace("Driver", "").lower()
+                # Class-name fallback. Strip the Async prefix first:
+                # AsyncClaudeDriver is still the "claude" provider, and
+                # "asyncclaude" vs "claude" would split one provider's
+                # spend into two rows.
+                cls_name = self.__class__.__name__.removeprefix("Async")
+                provider = cls_name.removesuffix("Driver").lower()
                 model = driver_name
 
             model_name = f"{provider}/{model}" if provider else model

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/async_cohere_embedding_driver.py

@@ -102,7 +102,7 @@ class AsyncCohereEmbeddingDriver(EmbeddingCostMixin, AsyncEmbeddingDriver):
                 "dimensions": actual_dims,
                 "total_tokens": total_tokens,
                 "input_tokens": total_tokens,
-                "cost": round(cost, 6),
+                "cost": round(cost, 12),
                 "raw_response": last_resp,
             },
         }

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/async_embedding_base.py

@@ -7,6 +7,7 @@ import time
 from typing import Any
 
 from ..infra.callbacks import DriverCallbacks
+from ._media_usage import record_embedding_driver_usage
 
 logger = logging.getLogger("prompture.async_embedding_driver")
 
@@ -54,6 +55,10 @@ class AsyncEmbeddingDriver:
                 "on_error",
                 {"error": exc, "text_count": len(texts), "options": options, "driver": driver_name},
             )
+            record_embedding_driver_usage(
+                self, {}, (time.perf_counter() - t0) * 1000,
+                text_count=len(texts), status="error", error=exc,
+            )
             raise
         elapsed_ms = (time.perf_counter() - t0) * 1000
         meta = resp.get("meta", {})
@@ -75,6 +80,7 @@ class AsyncEmbeddingDriver:
                 "elapsed_ms": elapsed_ms,
             },
         )
+        record_embedding_driver_usage(self, meta, elapsed_ms, text_count=len(texts))
         return resp
 
     # ------------------------------------------------------------------

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/async_img_gen_base.py

@@ -7,6 +7,7 @@ import time
 from typing import Any
 
 from ..infra.callbacks import DriverCallbacks
+from ._media_usage import record_media_usage
 
 logger = logging.getLogger("prompture.async_img_gen_driver")
 
@@ -59,6 +60,10 @@ class AsyncImageGenDriver:
                 "on_error",
                 {"error": exc, "prompt_length": len(prompt), "options": options, "driver": driver_name},
             )
+            record_media_usage(
+                self, {}, (time.perf_counter() - t0) * 1000,
+                modality="image", count_key="image_count", status="error", error=exc,
+            )
             raise
         elapsed_ms = (time.perf_counter() - t0) * 1000
         meta = resp.get("meta", {})
@@ -78,6 +83,7 @@ class AsyncImageGenDriver:
                 "elapsed_ms": elapsed_ms,
             },
         )
+        record_media_usage(self, meta, elapsed_ms, modality="image", count_key="image_count")
         return resp
 
     # ------------------------------------------------------------------

{prompture-1.9.1.dev1 → prompture-1.9.1.dev2}/prompture/drivers/async_jina_embedding_driver.py

@@ -90,7 +90,7 @@ class AsyncJinaEmbeddingDriver(EmbeddingCostMixin, AsyncEmbeddingDriver):
                 "dimensions": actual_dims,
                 "total_tokens": total_tokens,
                 "input_tokens": total_tokens,
-                "cost": round(cost, 6),
+                "cost": round(cost, 12),
                 "raw_response": last_resp,
             },
         }