prompture 1.9.1.dev1__tar.gz → 1.9.1.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 1.9.1.dev1
+Version: 1.9.1.dev3
 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.dev3}/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.dev3'
+__version_tuple__ = version_tuple = (1, 9, 1, 'dev3')
 
 __commit_id__ = commit_id = None

{prompture-1.9.1.dev1 → prompture-1.9.1.dev3}/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):
@@ -378,6 +387,44 @@ class Agent(Generic[DepsType]):
         """Set agent-level callbacks."""
         self._agent_callbacks = value
 
+    @property
+    def driver(self):
+        """The driver instance this agent will run against, or ``None``."""
+        return self._driver
+
+    @driver.setter
+    def driver(self, value) -> None:
+        """Swap the driver (e.g. per-tenant credentials).
+
+        A persistent conversation built against the old driver is detected as
+        stale on the next run and rebuilt, so the swap takes effect there too.
+        """
+        self._driver = value
+
+    @property
+    def options(self) -> dict[str, Any]:
+        """Live per-call options dict (temperature, max_tokens, ...).
+
+        Mutations (``agent.options["temperature"] = 0.2``) apply from the
+        next run onward.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, value: dict[str, Any] | None) -> None:
+        self._options = dict(value) if value else {}
+
+    @property
+    def system_prompt(self):
+        """The configured system prompt (str, Persona, or callable)."""
+        return self._system_prompt
+
+    @system_prompt.setter
+    def system_prompt(self, value) -> None:
+        """Replace the system prompt; re-resolved on every run, including
+        for persistent conversations."""
+        self._system_prompt = value
+
     @property
     def conversation(self) -> Conversation | None:
         """The current persistent conversation, or ``None``."""
@@ -881,6 +928,9 @@ class Agent(Generic[DepsType]):
                 # Respect the newly resolved system prompt for this run.
                 if system_prompt is not None:
                     conv.system_prompt = system_prompt
+                # Pick up option mutations made since the conversation was
+                # built (agent.options is a live public dict).
+                conv._options = dict(self._options)
                 # Update tools and callbacks for this run.
                 # NOTE: assigning ``callbacks`` mutates the driver instance,
                 # which may be shared (e.g. passed to several agents).  A
@@ -1176,7 +1226,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.dev3}/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.dev3}/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
@@ -321,6 +321,44 @@ class AsyncAgent(Generic[DepsType]):
         """Set agent-level callbacks."""
         self._agent_callbacks = value
 
+    @property
+    def driver(self):
+        """The driver instance this agent will run against, or ``None``."""
+        return self._driver
+
+    @driver.setter
+    def driver(self, value) -> None:
+        """Swap the driver (e.g. per-tenant credentials).
+
+        A persistent conversation built against the old driver is detected as
+        stale on the next run and rebuilt, so the swap takes effect there too.
+        """
+        self._driver = value
+
+    @property
+    def options(self) -> dict[str, Any]:
+        """Live per-call options dict (temperature, max_tokens, ...).
+
+        Mutations (``agent.options["temperature"] = 0.2``) apply from the
+        next run onward.
+        """
+        return self._options
+
+    @options.setter
+    def options(self, value: dict[str, Any] | None) -> None:
+        self._options = dict(value) if value else {}
+
+    @property
+    def system_prompt(self):
+        """The configured system prompt (str, Persona, or callable)."""
+        return self._system_prompt
+
+    @system_prompt.setter
+    def system_prompt(self, value) -> None:
+        """Replace the system prompt; re-resolved on every run, including
+        for persistent conversations."""
+        self._system_prompt = value
+
     @property
     def conversation(self) -> Any:
         """The current persistent conversation, or ``None``."""
@@ -921,6 +959,9 @@ class AsyncAgent(Generic[DepsType]):
                 # Respect the newly resolved system prompt for this run.
                 if system_prompt is not None:
                     conv.system_prompt = system_prompt
+                # Pick up option mutations made since the conversation was
+                # built (agent.options is a live public dict).
+                conv._options = dict(self._options)
                 # NOTE: assigning ``callbacks`` mutates the driver instance,
                 # which may be shared (e.g. passed to several agents).  A
                 # persistent-conversation agent should treat its driver as
@@ -1150,8 +1191,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 +1252,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.dev1 → prompture-1.9.1.dev3}/prompture/agents/async_conversation.py

@@ -187,6 +187,19 @@ class AsyncConversation:
         """The reasoning/thinking content from the last LLM response, if any."""
         return self._last_reasoning
 
+    def _assistant_message(self, content: str) -> dict[str, Any]:
+        """Assistant history entry for the response just consumed.
+
+        Attaches ``reasoning_content`` when the response carried it, so the
+        trace survives in history on every path (plain ask, tool loop,
+        streaming, JSON asks) -- not only the with-tool-calls branch -- and
+        providers that require reasoning to be echoed back keep working.
+        """
+        msg: dict[str, Any] = {"role": "assistant", "content": content}
+        if self._last_reasoning:
+            msg["reasoning_content"] = self._last_reasoning
+        return msg
+
     @property
     def messages(self) -> list[dict[str, Any]]:
         """Read-only view of the conversation history."""
@@ -546,7 +559,7 @@ class AsyncConversation:
         text: str = resp.get("text", "")
         self._last_reasoning = resp.get("reasoning_content")
         self._accumulate_usage(resp.get("meta", {}))
-        self._messages.append({"role": "assistant", "content": text})
+        self._messages.append(self._assistant_message(text))
         return text
 
     async def _final_answer_simulated(self, augmented_system: str, merged: dict[str, Any]) -> str:
@@ -642,7 +655,7 @@ class AsyncConversation:
 
         user_content = self._build_content_with_images(content, images)
         self._messages.append({"role": "user", "content": user_content})
-        self._messages.append({"role": "assistant", "content": text})
+        self._messages.append(self._assistant_message(text))
         self._accumulate_usage(meta)
 
         return text
@@ -680,7 +693,7 @@ class AsyncConversation:
 
             if not tool_calls:
                 self._last_reasoning = resp.get("reasoning_content")
-                self._messages.append({"role": "assistant", "content": text})
+                self._messages.append(self._assistant_message(text))
                 return text
 
             # Ensure every tool call has a usable id so parallel calls
@@ -782,7 +795,7 @@ class AsyncConversation:
 
             if not tool_calls:
                 self._last_reasoning = resp.get("reasoning_content")
-                self._messages.append({"role": "assistant", "content": text})
+                self._messages.append(self._assistant_message(text))
                 yield {"type": "text_delta", "text": text}
                 return
 
@@ -1259,7 +1272,7 @@ class AsyncConversation:
             )
             raise
 
-        self._messages.append({"role": "assistant", "content": full_text})
+        self._messages.append(self._assistant_message(full_text))
 
     async def ask_stream(
         self,
@@ -1382,7 +1395,7 @@ class AsyncConversation:
             else:
                 raise
 
-        self._messages.append({"role": "assistant", "content": cleaned})
+        self._messages.append(self._assistant_message(cleaned))
         self._accumulate_usage(meta)
 
         model_name = self._model_name

{prompture-1.9.1.dev1 → prompture-1.9.1.dev3}/prompture/agents/conversation.py

@@ -189,6 +189,19 @@ class Conversation:
         """The reasoning/thinking content from the last LLM response, if any."""
         return self._last_reasoning
 
+    def _assistant_message(self, content: str) -> dict[str, Any]:
+        """Assistant history entry for the response just consumed.
+
+        Attaches ``reasoning_content`` when the response carried it, so the
+        trace survives in history on every path (plain ask, tool loop,
+        streaming, JSON asks) -- not only the with-tool-calls branch -- and
+        providers that require reasoning to be echoed back keep working.
+        """
+        msg: dict[str, Any] = {"role": "assistant", "content": content}
+        if self._last_reasoning:
+            msg["reasoning_content"] = self._last_reasoning
+        return msg
+
     @property
     def messages(self) -> list[dict[str, Any]]:
         """Read-only view of the conversation history."""
@@ -550,7 +563,7 @@ class Conversation:
         text: str = resp.get("text", "")
         self._last_reasoning = resp.get("reasoning_content")
         self._accumulate_usage(resp.get("meta", {}))
-        self._messages.append({"role": "assistant", "content": text})
+        self._messages.append(self._assistant_message(text))
         return text
 
     def _final_answer_simulated(self, augmented_system: str, merged: dict[str, Any]) -> str:
@@ -656,7 +669,7 @@ class Conversation:
         # Record in history — store content with images for context
         user_content = self._build_content_with_images(content, images)
         self._messages.append({"role": "user", "content": user_content})
-        self._messages.append({"role": "assistant", "content": text})
+        self._messages.append(self._assistant_message(text))
         self._accumulate_usage(meta)
 
         return text
@@ -696,7 +709,7 @@ class Conversation:
             if not tool_calls:
                 # No tool calls -> final response
                 self._last_reasoning = resp.get("reasoning_content")
-                self._messages.append({"role": "assistant", "content": text})
+                self._messages.append(self._assistant_message(text))
                 return text
 
             # Ensure every tool call has a usable id so parallel calls
@@ -808,7 +821,7 @@ class Conversation:
             if not tool_calls:
                 # Final response — stream it if possible
                 self._last_reasoning = resp.get("reasoning_content")
-                self._messages.append({"role": "assistant", "content": text})
+                self._messages.append(self._assistant_message(text))
                 # Yield final text as deltas (single chunk since we already have the full text)
                 yield {"type": "text_delta", "text": text}
                 return
@@ -1296,7 +1309,7 @@ class Conversation:
             )
             raise
 
-        self._messages.append({"role": "assistant", "content": full_text})
+        self._messages.append(self._assistant_message(full_text))
 
     def ask_stream(
         self,
@@ -1517,7 +1530,7 @@ class Conversation:
                 raise
 
         # Store assistant response in history
-        self._messages.append({"role": "assistant", "content": cleaned})
+        self._messages.append(self._assistant_message(cleaned))
         self._accumulate_usage(meta)
 
         model_name = self._model_name

prompture-1.9.1.dev3/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