agentx-python 0.6.14__tar.gz → 0.6.15__tar.gz

{agentx_python-0.6.14/agentx_python.egg-info → agentx_python-0.6.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.14
+Version: 0.6.15
 Summary: Official Python SDK for AgentX (https://www.agentx.so/)
 Home-page: https://github.com/AgentX-ai/AgentX-python
 Author: Robin Wang and AgentX Team
@@ -228,7 +228,12 @@ with tracer.trace("rag-agent", framework="langchain") as span:
 
 ### Framework integrations
 
-Each integration auto-captures LLM calls, tool calls, and token usage — install the matching extra:
+Each integration auto-captures LLM calls, tool calls, and token usage — including prompt-caching
+token counts (Anthropic's cache write/read, OpenAI/LiteLLM's cached tokens, Google GenAI's cached
+content), reported as their own `cache_read_tokens`/`cache_write_tokens` fields alongside the
+regular totals, no extra config needed. Self-host's cost estimate prices these separately from a
+regular input token when you've set optional cache rates on that model. Install the matching
+extra:
 
 | Framework             | Install                                      | Integration              |
 | --------------------- | -------------------------------------------- | ------------------------ |

{agentx_python-0.6.14 → agentx_python-0.6.15}/README.md

@@ -166,7 +166,12 @@ with tracer.trace("rag-agent", framework="langchain") as span:
 
 ### Framework integrations
 
-Each integration auto-captures LLM calls, tool calls, and token usage — install the matching extra:
+Each integration auto-captures LLM calls, tool calls, and token usage — including prompt-caching
+token counts (Anthropic's cache write/read, OpenAI/LiteLLM's cached tokens, Google GenAI's cached
+content), reported as their own `cache_read_tokens`/`cache_write_tokens` fields alongside the
+regular totals, no extra config needed. Self-host's cost estimate prices these separately from a
+regular input token when you've set optional cache rates on that model. Install the matching
+extra:
 
 | Framework             | Install                                      | Integration              |
 | --------------------- | -------------------------------------------- | ------------------------ |

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/integrations/_traced_call.py

@@ -77,6 +77,8 @@ def finish_llm_call(
     input_tokens: Optional[int],
     output_tokens: Optional[int],
     error: Optional[str],
+    cache_read_tokens: Optional[int] = None,
+    cache_write_tokens: Optional[int] = None,
 ) -> None:
     """
     Close out one raw-client LLM call — shared by the ``on_finish``/exit
@@ -107,6 +109,8 @@ def finish_llm_call(
             model=model,
             input_tokens=input_tokens,
             output_tokens=output_tokens,
+            cache_read_tokens=cache_read_tokens,
+            cache_write_tokens=cache_write_tokens,
         )
         return
 
@@ -121,4 +125,8 @@ def finish_llm_call(
         span._input_tokens = input_tokens
     if output_tokens:
         span._output_tokens = output_tokens
+    if cache_read_tokens:
+        span._cache_read_tokens = cache_read_tokens
+    if cache_write_tokens:
+        span._cache_write_tokens = cache_write_tokens
     span.__exit__(None, None, None)

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/integrations/anthropic.py

@@ -70,23 +70,26 @@ def _prepend_system(messages: Any, system: Any) -> Any:
     return [system_entry, messages]
 
 
-def _extract_usage_tokens(usage: Any) -> Tuple[Optional[int], Optional[int]]:
+def _extract_usage_tokens(
+    usage: Any,
+) -> Tuple[Optional[int], Optional[int], Optional[int], Optional[int]]:
     """
-    Pull input/output token counts off a ``response.usage`` object, folding
-    prompt-caching tokens (``cache_creation_input_tokens`` /
-    ``cache_read_input_tokens``) into the input total — they're still real
-    input tokens for cost/context-window purposes, and the backend has no
-    separate column for them today.
+    Pull input/output/cache token counts off a ``response.usage`` object.
+    ``input_tokens`` stays the *total* (base + cache_creation + cache_read) —
+    still real input tokens for cost/context-window purposes — while
+    ``cache_read``/``cache_write`` are reported alongside as the subset of
+    that total the provider actually billed at a different (cache) rate, so
+    the backend can price them separately instead of at the full input rate.
     """
     if usage is None:
-        return None, None
+        return None, None, None, None
     input_tokens = getattr(usage, "input_tokens", None)
     output_tokens = getattr(usage, "output_tokens", None)
     cache_creation = getattr(usage, "cache_creation_input_tokens", None)
     cache_read = getattr(usage, "cache_read_input_tokens", None)
     if cache_creation or cache_read:
         input_tokens = (input_tokens or 0) + (cache_creation or 0) + (cache_read or 0)
-    return input_tokens, output_tokens
+    return input_tokens, output_tokens, cache_read, cache_creation
 
 
 def patch_anthropic_client(
@@ -141,10 +144,14 @@ def _patch_create(
             output = None
             input_tokens = None
             output_tokens = None
+            cache_read_tokens = None
+            cache_write_tokens = None
             if response is not None:
                 output = _extract_output_text(response)
                 try:
-                    input_tokens, output_tokens = _extract_usage_tokens(getattr(response, "usage", None))
+                    input_tokens, output_tokens, cache_read_tokens, cache_write_tokens = _extract_usage_tokens(
+                        getattr(response, "usage", None)
+                    )
                 except Exception:
                     pass
 
@@ -161,6 +168,8 @@ def _patch_create(
                 model=model,
                 input_tokens=input_tokens,
                 output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
+                cache_write_tokens=cache_write_tokens,
                 error=error,
             )
 
@@ -195,10 +204,14 @@ def _patch_stream(
             output = None
             input_tokens = None
             output_tokens = None
+            cache_read_tokens = None
+            cache_write_tokens = None
             if final_message is not None:
                 output = _extract_output_text(final_message)
                 try:
-                    input_tokens, output_tokens = _extract_usage_tokens(getattr(final_message, "usage", None))
+                    input_tokens, output_tokens, cache_read_tokens, cache_write_tokens = _extract_usage_tokens(
+                        getattr(final_message, "usage", None)
+                    )
                 except Exception:
                     pass
             finish_llm_call(
@@ -214,6 +227,8 @@ def _patch_stream(
                 model=model,
                 input_tokens=input_tokens,
                 output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
+                cache_write_tokens=cache_write_tokens,
                 error=error,
             )
 

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/integrations/google_genai.py

@@ -112,11 +112,16 @@ def _patch_generate_content(
             output = _extract_response_text(response) if response is not None else None
             input_tokens = None
             output_tokens = None
+            cache_read_tokens = None
             if response is not None:
                 usage = getattr(response, "usage_metadata", None)
                 if usage is not None:
                     input_tokens = getattr(usage, "prompt_token_count", None)
                     output_tokens = getattr(usage, "candidates_token_count", None)
+                    # prompt_token_count already includes this — a discount breakdown, same
+                    # "total unchanged, cache portion reported alongside" posture as OpenAI's
+                    # prompt_tokens_details.cached_tokens.
+                    cache_read_tokens = getattr(usage, "cached_content_token_count", None)
             finish_llm_call(
                 tracer,
                 name=name,
@@ -130,6 +135,7 @@ def _patch_generate_content(
                 model=str(model) if model else None,
                 input_tokens=input_tokens,
                 output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
                 error=error,
             )
 
@@ -195,9 +201,11 @@ def _patch_sync_generate_content_stream(
             end_t = time.time()
             input_tokens = None
             output_tokens = None
+            cache_read_tokens = None
             if last_usage_metadata is not None:
                 input_tokens = getattr(last_usage_metadata, "prompt_token_count", None)
                 output_tokens = getattr(last_usage_metadata, "candidates_token_count", None)
+                cache_read_tokens = getattr(last_usage_metadata, "cached_content_token_count", None)
             output_repr = "".join(accumulated_text) or None
             finish_llm_call(
                 tracer,
@@ -212,6 +220,7 @@ def _patch_sync_generate_content_stream(
                 model=model,
                 input_tokens=input_tokens,
                 output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
                 error=error,
             )
 
@@ -260,9 +269,11 @@ def _patch_async_generate_content_stream(
                 end_t = time.time()
                 input_tokens = None
                 output_tokens = None
+                cache_read_tokens = None
                 if last_usage_metadata is not None:
                     input_tokens = getattr(last_usage_metadata, "prompt_token_count", None)
                     output_tokens = getattr(last_usage_metadata, "candidates_token_count", None)
+                    cache_read_tokens = getattr(last_usage_metadata, "cached_content_token_count", None)
                 output_repr = "".join(accumulated_text) or None
                 finish_llm_call(
                     tracer,
@@ -277,6 +288,7 @@ def _patch_async_generate_content_stream(
                     model=model,
                     input_tokens=input_tokens,
                     output_tokens=output_tokens,
+                    cache_read_tokens=cache_read_tokens,
                     error=error,
                 )
 

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/integrations/litellm.py

@@ -56,11 +56,16 @@ def _extract_output_text(response: Any) -> Optional[str]:
     return None
 
 
-def _extract_usage_tokens(response: Any) -> Tuple[Optional[int], Optional[int]]:
+def _extract_usage_tokens(response: Any) -> Tuple[Optional[int], Optional[int], Optional[int]]:
+    """Same posture as agentx.integrations.openai's own _extract_usage_tokens — LiteLLM normalizes
+    every provider's response to an OpenAI-shaped ModelResponse, so prompt_tokens_details.cached_tokens
+    is the right field here too regardless of which underlying provider actually served the call."""
     usage = getattr(response, "usage", None)
     if usage is None:
-        return None, None
-    return getattr(usage, "prompt_tokens", None), getattr(usage, "completion_tokens", None)
+        return None, None, None
+    details = getattr(usage, "prompt_tokens_details", None)
+    cached_tokens = getattr(details, "cached_tokens", None) if details is not None else None
+    return getattr(usage, "prompt_tokens", None), getattr(usage, "completion_tokens", None), cached_tokens
 
 
 class AgentXLiteLLMLogger(CustomLogger):
@@ -96,9 +101,10 @@ class AgentXLiteLLMLogger(CustomLogger):
         output = None
         input_tokens = None
         output_tokens = None
+        cache_read_tokens = None
         if error is None and response_obj is not None:
             output = _extract_output_text(response_obj)
-            input_tokens, output_tokens = _extract_usage_tokens(response_obj)
+            input_tokens, output_tokens, cache_read_tokens = _extract_usage_tokens(response_obj)
 
         finish_llm_call(
             self._tracer,
@@ -113,6 +119,7 @@ class AgentXLiteLLMLogger(CustomLogger):
             model=model,
             input_tokens=input_tokens,
             output_tokens=output_tokens,
+            cache_read_tokens=cache_read_tokens,
             error=error,
         )
 

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/integrations/openai.py

@@ -58,16 +58,21 @@ def _extract_output_text(response: Any) -> Optional[str]:
     return None
 
 
-def _extract_usage_tokens(usage: Any) -> Tuple[Optional[int], Optional[int]]:
+def _extract_usage_tokens(usage: Any) -> Tuple[Optional[int], Optional[int], Optional[int]]:
     """
-    Pull input/output token counts off a ``response.usage`` object.
+    Pull input/output/cached token counts off a ``response.usage`` object.
     ``prompt_tokens`` already includes cached tokens (``prompt_tokens_details
     .cached_tokens`` is a discount breakdown, not an addition), so — unlike
-    Anthropic's cache accounting — no extra folding is needed here.
+    Anthropic's cache accounting — no extra folding is needed for the input
+    total; ``cached_tokens`` is reported alongside it so the backend can
+    price that subset at its own (cheaper) cache rate instead of the full
+    input rate. OpenAI has no cache-*write* concept to report.
     """
     if usage is None:
-        return None, None
-    return getattr(usage, "prompt_tokens", None), getattr(usage, "completion_tokens", None)
+        return None, None, None
+    details = getattr(usage, "prompt_tokens_details", None)
+    cached_tokens = getattr(details, "cached_tokens", None) if details is not None else None
+    return getattr(usage, "prompt_tokens", None), getattr(usage, "completion_tokens", None), cached_tokens
 
 
 def patch_openai_client(
@@ -129,10 +134,13 @@ def _patch_chat_completions_create(
             output = None
             input_tokens = None
             output_tokens = None
+            cache_read_tokens = None
             if response is not None:
                 output = _extract_output_text(response)
                 try:
-                    input_tokens, output_tokens = _extract_usage_tokens(getattr(response, "usage", None))
+                    input_tokens, output_tokens, cache_read_tokens = _extract_usage_tokens(
+                        getattr(response, "usage", None)
+                    )
                 except Exception:
                     pass
 
@@ -149,6 +157,7 @@ def _patch_chat_completions_create(
                 model=model,
                 input_tokens=input_tokens,
                 output_tokens=output_tokens,
+                cache_read_tokens=cache_read_tokens,
                 error=error,
             )
 

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/monitor/models.py

@@ -117,6 +117,13 @@ class MonitorProfile(BaseModel):
     approval policy gating autotune actions. See ``client.monitor.profile.get()/update()``.
     ``None`` from ``get()`` means this agent has never been configured and is running on
     platform defaults (e.g. the built-in latency threshold defaults to 20000ms).
+
+    Self-host only: ``coverage_mode``/``sample_rate``/``retention_days``/``redaction_mode``, and
+    ``threshold_overrides["latencyMs"]`` are project-level defaults now (set once for every agent
+    via the dashboard's Platform Settings screen), not real per-agent settings — this model and
+    ``update()`` still accept/return them for wire compatibility, but a self-host engine no longer
+    reads the stored per-agent values for any behavior. ``enabled``/``failure_detection_enabled``/
+    ``info_detection_enabled``/``channels`` remain real per-agent settings on self-host too.
     """
 
     id: Optional[str] = Field(default=None, alias="_id")

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/monitor/profile.py

@@ -47,9 +47,15 @@ class MonitorProfileClient:
         """Update (and enable, if not already) this agent's Monitor profile. Only fields passed
         here are changed; everything else on the existing profile is left as is.
 
-        Example, overriding the built-in "Latency regression" pattern's threshold for one agent::
+        Self-host only: ``coverage_mode``/``sample_rate``/``retention_days``/``redaction_mode``,
+        and ``threshold_overrides["latencyMs"]`` are project-level defaults now (see
+        ``MonitorProfile``'s docstring) — set them via the dashboard's Platform Settings screen
+        instead, passing them here is accepted but has no effect. ``enabled``/
+        ``failure_detection_enabled``/``info_detection_enabled``/``channels`` still work per-agent.
 
-            client.monitor.profile.update("agent_123", threshold_overrides={"latencyMs": 15000})
+        Example (hosted, or self-host's still-per-agent fields)::
+
+            client.monitor.profile.update("agent_123", info_detection_enabled=False)
         """
         payload: Dict[str, Any] = {
             "enabled": enabled,

{agentx_python-0.6.14 → agentx_python-0.6.15}/agentx/tracing/tracer.py

@@ -70,6 +70,7 @@ class _TraceSpan:
         sync: bool = False,
         monitor: bool = False,
         pattern_ids: Optional[List[str]] = None,
+        agent_id: Optional[str] = None,
     ) -> None:
         self._tracer = tracer
         self.name = name
@@ -79,6 +80,10 @@ class _TraceSpan:
         self._framework = framework
         self._model = model
         self._session_id = session_id
+        # Disambiguator for when `name` alone isn't enough — pass an already-known agent id (e.g.
+        # from a prior GET /agents lookup) to pin this trace to that exact agent. None (the
+        # default) resolves from `name` alone server-side, one stable agent per distinct name.
+        self._agent_id = agent_id
         # When True, __exit__ sends synchronously (blocking) instead of enqueueing, so trace_id
         # is populated by the time the `with` block exits — see Tracer.trace()'s sync param.
         self._sync = sync
@@ -113,6 +118,10 @@ class _TraceSpan:
         self._captured_framework: Optional[str] = None
         self._input_tokens: int = 0
         self._output_tokens: int = 0
+        # Subsets of _input_tokens (not additional tokens) — a prompt-caching write/read, when the
+        # provider reports one. See _record_llm_call/child_span for where these get populated.
+        self._cache_read_tokens: int = 0
+        self._cache_write_tokens: int = 0
         # Guards _merge_child_run — with Tracer.use_span(), multiple threads
         # (e.g. a ThreadPoolExecutor) can merge into this span concurrently.
         self._merge_lock = threading.Lock()
@@ -146,6 +155,7 @@ class _TraceSpan:
             monitor=self._monitor or None,
             pattern_ids=self._pattern_ids,
             name=self.name,
+            agent_id=self._agent_id,
             input=_safe_serialize(self.input) if self.input is not None else None,
             output=_safe_serialize(self.output) if self.output is not None else None,
             latency_ms=latency_ms,
@@ -157,6 +167,8 @@ class _TraceSpan:
             session_id=self._session_id,
             input_tokens=self._input_tokens or None,
             output_tokens=self._output_tokens or None,
+            cache_read_tokens=self._cache_read_tokens or None,
+            cache_write_tokens=self._cache_write_tokens or None,
             span_id=self._span_id,
             parent_span_id=self._parent_span_id,
             started_at_unix_nano=str(int(self._start * 1_000_000_000)) if self._start else None,
@@ -193,6 +205,8 @@ class _TraceSpan:
         model: Optional[str] = None,
         input_tokens: Optional[int] = None,
         output_tokens: Optional[int] = None,
+        cache_read_tokens: Optional[int] = None,
+        cache_write_tokens: Optional[int] = None,
     ) -> None:
         """Record one LLM-call child span (e.g. one patched Anthropic call) under this span —
         name left unset so _merge_child_run auto-numbers it "LLM Call N"."""
@@ -206,12 +220,16 @@ class _TraceSpan:
                 "output": output,
                 "inputTokenSize": input_tokens,
                 "outputTokenSize": output_tokens,
+                "cacheReadTokenSize": cache_read_tokens,
+                "cacheWriteTokenSize": cache_write_tokens,
             }],
             input=input,
             output=output,
             model=model,
             input_tokens=input_tokens,
             output_tokens=output_tokens,
+            cache_read_tokens=cache_read_tokens,
+            cache_write_tokens=cache_write_tokens,
         )
 
     def child_span(
@@ -227,6 +245,8 @@ class _TraceSpan:
         framework: Optional[str] = None,
         input_tokens: Optional[int] = None,
         output_tokens: Optional[int] = None,
+        cache_read_tokens: Optional[int] = None,
+        cache_write_tokens: Optional[int] = None,
         error: Optional[str] = None,
         tool_calls: Optional[List[Dict[str, Any]]] = None,
     ) -> "_TraceSpan":
@@ -294,6 +314,10 @@ class _TraceSpan:
             wire["input_tokens"] = input_tokens
         if output_tokens:
             wire["output_tokens"] = output_tokens
+        if cache_read_tokens:
+            wire["cache_read_tokens"] = cache_read_tokens
+        if cache_write_tokens:
+            wire["cache_write_tokens"] = cache_write_tokens
         child._trace_id = self._tracer._dispatch(wire)
         return child
 
@@ -309,6 +333,8 @@ class _TraceSpan:
         framework: Optional[str] = None,
         input_tokens: Optional[int] = None,
         output_tokens: Optional[int] = None,
+        cache_read_tokens: Optional[int] = None,
+        cache_write_tokens: Optional[int] = None,
     ) -> None:
         """
         Explode a whole auto-instrumented sub-run (e.g. one top-level LangChain
@@ -333,6 +359,8 @@ class _TraceSpan:
                     model=step.get("model"),
                     input_tokens=step.get("inputTokenSize"),
                     output_tokens=step.get("outputTokenSize"),
+                    cache_read_tokens=step.get("cacheReadTokenSize"),
+                    cache_write_tokens=step.get("cacheWriteTokenSize"),
                 )
             for tc in tool_calls or []:
                 # Some callers' tool_calls dicts (e.g. langchain.py's, which sets these on the
@@ -348,6 +376,20 @@ class _TraceSpan:
                     input=tc.get("input"),
                     output=tc.get("output"),
                 )
+                # Also mirror onto this span's own flat tool_calls list, sent in this span's own
+                # wire payload on __exit__ (see tool_calls=self.tool_calls or None below). The
+                # child span above is only for the trace detail view's span tree; the engine's
+                # built-in "Tool failure" Monitor check reads *this* flat list specifically,
+                # looking for a `success: false` entry — a child span row has no such field, so
+                # without this a failed tool call recorded via a framework integration (e.g.
+                # langchain.py's on_tool_error) would silently never trip that check.
+                self.tool_calls.append({
+                    "name": tc.get("name") or "Tool call",
+                    "input": tc.get("input"),
+                    "output": tc.get("output"),
+                    "latency_ms": tc.get("latency_ms"),
+                    "success": tc.get("success", True),
+                })
             for step in retrieval_steps or []:
                 self._child_span_count += 1
                 self.child_span(
@@ -371,6 +413,10 @@ class _TraceSpan:
                 self._input_tokens += input_tokens
             if output_tokens:
                 self._output_tokens += output_tokens
+            if cache_read_tokens:
+                self._cache_read_tokens += cache_read_tokens
+            if cache_write_tokens:
+                self._cache_write_tokens += cache_write_tokens
 
     # ------------------------------------------------------------------
     # Context manager helpers
@@ -675,6 +721,7 @@ class Tracer:
         sync: bool = False,
         monitor: bool = False,
         pattern_ids: Optional[List[str]] = None,
+        agent_id: Optional[str] = None,
     ) -> _TraceSpan:
         """
         Return a :class:`_TraceSpan` that works as both a decorator and a
@@ -713,6 +760,15 @@ class Tracer:
 
             with client.tracer.trace("support_agent_call", monitor=True, pattern_ids=[pattern.id]) as span:
                 span.output = call_llm(...)
+
+        ``agent_id`` disambiguates when ``name`` alone isn't enough — pass an already-known agent
+        id (e.g. one you've seen in the dashboard's Overview tab, or from a direct ``GET /agents``
+        call) to pin this trace to that exact agent instead of resolving by name. Omit it (the
+        default) and this resolves from ``name`` alone — one stable agent per distinct name,
+        created on first use::
+
+            with client.tracer.trace("support-agent", agent_id="ag_123", sync=True) as span:
+                span.output = call_llm(...)
         """
         return _TraceSpan(
             tracer=self,
@@ -725,6 +781,7 @@ class Tracer:
             sync=sync,
             monitor=monitor,
             pattern_ids=pattern_ids,
+            agent_id=agent_id,
         )
 
     def flush(self, timeout: float = 5.0) -> None:
@@ -946,6 +1003,10 @@ class Tracer:
             wire["input_tokens"] = payload["input_tokens"]
         if "output_tokens" in payload:
             wire["output_tokens"] = payload["output_tokens"]
+        if "cache_read_tokens" in payload:
+            wire["cache_read_tokens"] = payload["cache_read_tokens"]
+        if "cache_write_tokens" in payload:
+            wire["cache_write_tokens"] = payload["cache_write_tokens"]
         if "monitor" in payload:
             wire["monitor"] = payload["monitor"]
         if "pattern_ids" in payload:
@@ -956,6 +1017,8 @@ class Tracer:
             wire["parent_span_id"] = payload["parent_span_id"]
         if "started_at_unix_nano" in payload:
             wire["started_at_unix_nano"] = payload["started_at_unix_nano"]
+        if "agent_id" in payload:
+            wire["agent_id"] = payload["agent_id"]
 
         pending_tool_calls, self._pending_tool_calls = self._pending_tool_calls, []
         if pending_tool_calls:

agentx_python-0.6.15/agentx/version.py

@@ -0,0 +1 @@
+VERSION = "0.6.15"

{agentx_python-0.6.14 → agentx_python-0.6.15/agentx_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentx-python
-Version: 0.6.14
+Version: 0.6.15
 Summary: Official Python SDK for AgentX (https://www.agentx.so/)
 Home-page: https://github.com/AgentX-ai/AgentX-python
 Author: Robin Wang and AgentX Team
@@ -228,7 +228,12 @@ with tracer.trace("rag-agent", framework="langchain") as span:
 
 ### Framework integrations
 
-Each integration auto-captures LLM calls, tool calls, and token usage — install the matching extra:
+Each integration auto-captures LLM calls, tool calls, and token usage — including prompt-caching
+token counts (Anthropic's cache write/read, OpenAI/LiteLLM's cached tokens, Google GenAI's cached
+content), reported as their own `cache_read_tokens`/`cache_write_tokens` fields alongside the
+regular totals, no extra config needed. Self-host's cost estimate prices these separately from a
+regular input token when you've set optional cache rates on that model. Install the matching
+extra:
 
 | Framework             | Install                                      | Integration              |
 | --------------------- | -------------------------------------------- | ------------------------ |

agentx_python-0.6.14/agentx/version.py

@@ -1 +0,0 @@
-VERSION = "0.6.14"