trodo-python 2.21.0__py3-none-any.whl → 2.23.0__py3-none-any.whl

trodo/otel/auto_instrument.py

@@ -401,6 +401,46 @@ class _OtelAdapter(_SpanProcessorBase):  # type: ignore[valid-type,misc]
         return True
 
 
+def _instrument(module_name: str, *preferred: str) -> None:
+    """Import ``module_name`` and call ``instrument()`` on its Instrumentor.
+
+    Upstream renames the exported class often enough that pinning one exact
+    spelling is a silent-failure generator: the import raises, the caller's
+    ``except Exception`` treats it as "package not installed", and the user who
+    installed exactly what we told them to gets no spans and no error. That is
+    how ``LangChainInstrumentor`` (upstream ships ``LangchainInstrumentor``) and
+    ``GoogleGenerativeAIInstrumentor`` both went dark.
+
+    So: try the known spellings in order, then fall back to whatever single
+    ``*Instrumentor`` the module exports. Mirrors ``instrCtor`` in the Node SDK.
+    Raises ImportError if nothing usable is found, which the caller reports.
+    """
+    import importlib
+
+    mod = importlib.import_module(module_name)
+    cls = None
+    for name in preferred:
+        cls = getattr(mod, name, None)
+        if cls is not None:
+            break
+    if cls is None:
+        found = [
+            n for n in dir(mod)
+            if n.endswith("Instrumentor") and n != "BaseInstrumentor"
+            and isinstance(getattr(mod, n, None), type)
+        ]
+        if len(found) == 1:
+            cls = getattr(mod, found[0])
+        elif found:
+            raise ImportError(
+                f"{module_name} exports several Instrumentor classes {found}; "
+                f"none matched the expected names {list(preferred)}"
+            )
+    if cls is None:
+        raise ImportError(f"no Instrumentor class exported by {module_name}")
+    cls().instrument()
+
+
 _INSTRUMENTORS: List[tuple[str, Callable[[], Any]]] = []
 
 
@@ -416,84 +456,49 @@ def _register_instrumentors() -> None:
         return
 
     def _anthropic() -> Any:
-        from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor  # type: ignore
-
-        AnthropicInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.anthropic", "AnthropicInstrumentor")
 
     def _openai() -> Any:
-        from opentelemetry.instrumentation.openai import OpenAIInstrumentor  # type: ignore
-
-        OpenAIInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.openai", "OpenAIInstrumentor")
 
     def _openai_v2() -> Any:
-        from opentelemetry.instrumentation.openai_v2 import OpenAIInstrumentor  # type: ignore
-
-        OpenAIInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.openai_v2", "OpenAIInstrumentor")
 
     def _langchain() -> Any:
-        from opentelemetry.instrumentation.langchain import LangChainInstrumentor  # type: ignore
-
-        LangChainInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.langchain", "LangchainInstrumentor", "LangChainInstrumentor")
 
     def _llama_index() -> Any:
-        from opentelemetry.instrumentation.llama_index import LlamaIndexInstrumentor  # type: ignore
-
-        LlamaIndexInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.llama_index", "LlamaIndexInstrumentor")
 
     def _google_generativeai() -> Any:
-        import opentelemetry.instrumentation.google_generativeai as _m  # type: ignore
-
-        # The exported class name varies by version: GoogleGenerativeAiInstrumentor
-        # (current — note the lowercase 'i'), GoogleGenerativeAIInstrumentor, or
-        # GenAIInstrumentor. Importing the wrong casing silently disabled Gemini
-        # auto-instrumentation. (This instrumentation patches the new @google/genai
-        # SDK, i.e. the `google-genai` package, not legacy google-generativeai.)
-        instr = (
-            getattr(_m, "GoogleGenerativeAiInstrumentor", None)
-            or getattr(_m, "GoogleGenerativeAIInstrumentor", None)
-            or getattr(_m, "GenAIInstrumentor", None)
+        # Patches the new google-genai SDK, not legacy google-generativeai.
+        _instrument(
+            "opentelemetry.instrumentation.google_generativeai",
+            "GoogleGenerativeAiInstrumentor",
+            "GoogleGenerativeAIInstrumentor",
+            "GenAIInstrumentor",
         )
-        if instr is None:
-            raise ImportError(
-                "no GoogleGenerativeAi/GenAI Instrumentor in "
-                "opentelemetry.instrumentation.google_generativeai"
-            )
-        instr().instrument()
 
     def _vertexai() -> Any:
-        from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor  # type: ignore
-
-        VertexAIInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.vertexai", "VertexAIInstrumentor")
 
     def _bedrock() -> Any:
-        from opentelemetry.instrumentation.bedrock import BedrockInstrumentor  # type: ignore
-
-        BedrockInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.bedrock", "BedrockInstrumentor")
 
     def _cohere() -> Any:
-        from opentelemetry.instrumentation.cohere import CohereInstrumentor  # type: ignore
-
-        CohereInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.cohere", "CohereInstrumentor")
 
     def _mistralai() -> Any:
-        from opentelemetry.instrumentation.mistralai import MistralAiInstrumentor  # type: ignore
-
-        MistralAiInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.mistralai", "MistralAiInstrumentor")
 
     def _haystack() -> Any:
-        from opentelemetry.instrumentation.haystack import HaystackInstrumentor  # type: ignore
-
-        HaystackInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.haystack", "HaystackInstrumentor")
 
     def _httpx() -> Any:
-        from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor  # type: ignore
-
-        HTTPXClientInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.httpx", "HTTPXClientInstrumentor")
 
     def _requests() -> Any:
-        from opentelemetry.instrumentation.requests import RequestsInstrumentor  # type: ignore
-
-        RequestsInstrumentor().instrument()
+        _instrument("opentelemetry.instrumentation.requests", "RequestsInstrumentor")
 
     _INSTRUMENTORS = [
         ("anthropic", _anthropic),

trodo/otel/prompt_trace.py

@@ -14,6 +14,7 @@ Mirrors ``sdks/trodo-node-sdk/src/otel/promptTrace.ts``.
 
 from __future__ import annotations
 
+from collections import OrderedDict
 from typing import Any, Dict, List, Optional
 
 from .context import get_active_context
@@ -27,6 +28,55 @@ def new_prompt_state() -> Dict[str, Any]:
     return {"current": None, "all": []}
 
 
+# Compiled prompt (or its messages list) -> the version it came from.
+#
+# Mirrors the Node SDK. The run-scope mechanism below only fires when compile()
+# runs inside a run, which leaves the ordinary "fetch and compile up front, open
+# the run around the model call" shape with no link at all. Tagging the compiled
+# value means a span handed those messages as ``input`` recovers the version
+# wherever compile() happened.
+#
+# Keyed by id() with a weak-ish discipline: lists are unhashable and cannot go
+# in a WeakValueDictionary, so entries are bounded and evicted FIFO rather than
+# held forever. The link is best-effort — losing an old entry costs one span's
+# label, never correctness.
+_MAX_CARRIERS = 4096
+_carrier_refs: "OrderedDict[int, PromptRef]" = OrderedDict()
+_carrier_keepalive: "OrderedDict[int, Any]" = OrderedDict()
+
+
+def tag_carrier_with_prompt(carrier: Any, ref: PromptRef) -> None:
+    """Attach a prompt identity to a value the caller will pass to a span."""
+    if carrier is None or isinstance(carrier, (str, bytes, int, float, bool)):
+        return
+    key = id(carrier)
+    _carrier_refs[key] = ref
+    # Hold a reference so the id cannot be recycled by another object while the
+    # mapping still names it — that would mislabel an unrelated span.
+    _carrier_keepalive[key] = carrier
+    _carrier_refs.move_to_end(key)
+    _carrier_keepalive.move_to_end(key)
+    while len(_carrier_refs) > _MAX_CARRIERS:
+        old, _ = _carrier_refs.popitem(last=False)
+        _carrier_keepalive.pop(old, None)
+
+
+def prompt_ref_from_carrier(carrier: Any) -> Optional[PromptRef]:
+    """Recover the prompt identity from a span's input, if it carries one."""
+    if carrier is None or isinstance(carrier, (str, bytes, int, float, bool)):
+        return None
+    return _carrier_refs.get(id(carrier))
+
+
+def remember_prompt(state: Any, ref: PromptRef) -> None:
+    """Add a ref to the run's deduped set if it isn't already there."""
+    if not isinstance(state, dict) or not ref or not ref.get("name"):
+        return
+    key = _ref_key(ref)
+    if not any(_ref_key(r) == key for r in state.get("all", [])):
+        state.setdefault("all", []).append(ref)
+
+
 def _ref_key(ref: PromptRef) -> str:
     return ref.get("version_hash") or ref.get("name") or ""
 
@@ -66,12 +116,24 @@ def prompt_attributes(ref: Optional[PromptRef]) -> Dict[str, str]:
 
 
 def merge_prompt_attrs(
-    active: Any, attrs: Optional[Dict[str, Any]]
+    active: Any, attrs: Optional[Dict[str, Any]], from_input: Optional[PromptRef] = None
 ) -> Optional[Dict[str, Any]]:
-    """Merge the active run's most-recently-compiled prompt into span attributes."""
+    """Merge the prompt this span used into its attributes.
+
+    The span's own INPUT wins over the run's most-recently-compiled prompt: it
+    is more specific (in a run using two prompts, a span holding prompt A's
+    messages must report A even if B was compiled later), and it is the only
+    signal available when compile() ran outside the run.
+
+    A prompt found this way is also folded into the run's deduped set so the
+    run-level ``trodo.prompts`` list stays complete either way.
+    """
     merged: Dict[str, Any] = dict(attrs or {})
     state = getattr(active, "prompt_state", None) if active is not None else None
-    if isinstance(state, dict):
+    if from_input is not None:
+        remember_prompt(state, from_input)
+        merged.update(prompt_attributes(from_input))
+    elif isinstance(state, dict):
         merged.update(prompt_attributes(state.get("current")))
     return merged or None
 

trodo/otel/wrap_agent.py

@@ -32,7 +32,12 @@ from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from .context import ActiveSpanContext, get_active_context, run_with_context
-from .prompt_trace import merge_prompt_attrs, new_prompt_state
+from .prompt_trace import (
+    merge_prompt_attrs,
+    new_prompt_state,
+    prompt_ref_from_carrier,
+    remember_prompt,
+)
 from .processor import TrodoSpanProcessor, TrodoRun, TrodoSpan
 from .transport import get_transport_mode, get_otel_tracer, get_otel_helpers
 
@@ -281,13 +286,21 @@ def _tag_error_with_run(exc: object, run_id: Optional[str]) -> None:
 class RunHandle:
     """Handle returned by wrap_agent for setting input/output and getting run_id."""
 
-    def __init__(self, run_id: str, agent_name: str, distinct_id: str) -> None:
+    def __init__(
+        self,
+        run_id: str,
+        agent_name: str,
+        distinct_id: str,
+        prompt_state: Optional[Dict[str, Any]] = None,
+    ) -> None:
         self.run_id = run_id
         self.agent_name = agent_name
         # Always populated — wrap_agent mints anon if caller didn't pass one
         # so downstream ``trodo.feedback(distinct_id=...)`` always has a target.
         self.distinct_id = distinct_id
         self.input: Optional[Union[str, Dict[str, Any]]] = None
+        #: The run's prompt accumulator, so set_input can register a prompt.
+        self._prompt_state = prompt_state
         self.output: Optional[Union[str, Dict[str, Any]]] = None
         self.metadata: Dict[str, Any] = {}
         # Manually-recorded run-level error (via set_error_summary). When set
@@ -298,7 +311,16 @@ class RunHandle:
     def set_input(self, value: Any) -> None:
         """Set the run input. Prefer a chat-message list
         ``[{"role": "user", "content": ...}, ...]`` — the backend embeds the
-        user messages as the run's semantic input."""
+        user messages as the run's semantic input.
+
+        Handing this the messages from a managed prompt also records that
+        prompt on the run: ``run.set_input(compiled.messages)`` is a common
+        shape, and the run demonstrably used that prompt, so the run-level
+        ``trodo.prompts`` list should say so even when compile() ran outside
+        the run."""
+        ref = prompt_ref_from_carrier(value)
+        if ref is not None:
+            remember_prompt(self._prompt_state, ref)
         self.input = _prepare_value(value)
 
     def set_output(self, value: Any) -> None:
@@ -330,6 +352,10 @@ class SpanHandle:
         self.span_id = span_id
         self.name = name
         self.input: Optional[Union[str, Dict[str, Any]]] = None
+        #: Prompt this span used, recovered from the value passed as input.
+        #: Captured from the ORIGINAL object: _prepare_value JSON-serialises
+        #: anything that isn't a dict/list, and identity cannot survive that.
+        self.prompt_ref: Optional[Dict[str, Any]] = None
         self.output: Optional[Union[str, Dict[str, Any]]] = None
         self.attributes: Dict[str, Any] = {}
         self.model: Optional[str] = None
@@ -393,6 +419,7 @@ class SpanHandle:
         ``context`` for RAG docs, any order, multiple per role) — each role is
         embedded separately and powers the AI-score detectors. Anything else
         is stored as one opaque input."""
+        self.prompt_ref = prompt_ref_from_carrier(value) or self.prompt_ref
         self.input = _prepare_value(value)
 
     def set_output(self, value: Any) -> None:
@@ -594,7 +621,6 @@ class wrap_agent:
         self._started_iso = _now_iso()
         self._started_ms = time.time() * 1000.0
 
-        self.handle = RunHandle(run_id, self._agent_name, self._distinct_id)
         ctx = ActiveSpanContext(
             run_id=run_id,
             span_id=root_span_id,
@@ -603,6 +629,9 @@ class wrap_agent:
             processor=self._processor,
             prompt_state=new_prompt_state(),
         )
+        self.handle = RunHandle(
+            run_id, self._agent_name, self._distinct_id, ctx.prompt_state
+        )
         self._ctx = ctx
         self._ctx_mgr = run_with_context(ctx)
         self._ctx_mgr.__enter__()
@@ -708,7 +737,12 @@ class wrap_agent:
                 otel_span.set_attribute(f"trodo.metadata.{k}", _serialize_attr(v))
 
         self._otel_span = otel_span
-        self.handle = RunHandle(run_id, self._agent_name, self._distinct_id)
+        # OTLP mode builds no Trodo run context (documented limitation), so
+        # the handle gets a standalone accumulator — enough for set_input() to
+        # register a prompt even here.
+        self.handle = RunHandle(
+            run_id, self._agent_name, self._distinct_id, new_prompt_state()
+        )
         return self.handle
 
     def _exit_otel(self, exc_type, exc, tb) -> None:
@@ -770,6 +804,7 @@ class join_run:
         self._parent_span_id = parent_span_id
         self._name = name
         self._kind = kind
+        self._prompt_ref = prompt_ref_from_carrier(input)
         self._input = _prepare_value(input) if input is not None else None
         self._attributes = attributes
         self._ctx_mgr: Optional[run_with_context] = None
@@ -786,6 +821,8 @@ class join_run:
         self.handle = SpanHandle(self._span_id, self._name)
         if self._input is not None:
             self.handle.input = self._input
+        if self._prompt_ref is not None:
+            self.handle.prompt_ref = self._prompt_ref
         if self._attributes:
             self.handle.attributes.update(self._attributes)
 
@@ -838,7 +875,9 @@ class join_run:
             cost_details=self.handle.cost_details,
             temperature=self.handle.temperature,
             tool_name=self.handle.tool_name,
-            attributes=merge_prompt_attrs(self._ctx, self.handle.attributes),
+            attributes=merge_prompt_attrs(
+                self._ctx, self.handle.attributes, self.handle.prompt_ref
+            ),
         )
         try:
             self._processor.append_spans(self._run_id, [trodo_span])
@@ -865,6 +904,7 @@ class span:
     ) -> None:
         self._name = name
         self._kind = kind
+        self._prompt_ref = prompt_ref_from_carrier(input)
         self._input = _prepare_value(input) if input is not None else None
         self._attributes = attributes
         self._ctx_mgr: Optional[run_with_context] = None
@@ -889,6 +929,8 @@ class span:
         self.handle = SpanHandle(self._span_id, self._name)
         if self._input is not None:
             self.handle.input = self._input
+        if self._prompt_ref is not None:
+            self.handle.prompt_ref = self._prompt_ref
         if self._attributes:
             self.handle.attributes.update(self._attributes)
         if self._active is None:
@@ -945,7 +987,9 @@ class span:
             cost_details=self.handle.cost_details,
             temperature=self.handle.temperature,
             tool_name=self.handle.tool_name,
-            attributes=merge_prompt_attrs(self._active, self.handle.attributes),
+            attributes=merge_prompt_attrs(
+                self._active, self.handle.attributes, self.handle.prompt_ref
+            ),
         )
         processor: TrodoSpanProcessor = self._active.processor  # type: ignore[assignment]
         processor.enqueue_span(trodo_span)
@@ -971,6 +1015,8 @@ class span:
         self.handle = SpanHandle(self._span_id, self._name)
         if self._input is not None:
             self.handle.input = self._input
+        if self._prompt_ref is not None:
+            self.handle.prompt_ref = self._prompt_ref
         if self._attributes:
             self.handle.attributes.update(self._attributes)
         return self.handle

trodo/prompts/compile.py

@@ -36,6 +36,36 @@ def _q(value: Any) -> str:
     except (TypeError, ValueError):
         return repr(value)
 
+def _js_string(value: Any) -> str:
+    """JavaScript ``String()`` semantics, byte-for-byte.
+
+    A non-string passed for a string-typed variable is a caller type mismatch,
+    but all three engines must agree on what it renders as -- the backend
+    reference (which powers the playground) and the Node SDK both go through
+    JS ``String()``, so ``True`` must render ``true``, ``3.0`` must render
+    ``3``, a list joins with commas, and a dict renders the infamous
+    ``[object Object]``. The JSON rendering callers actually want lives on the
+    ``json`` variable type, where all three engines already emit compact JSON.
+    """
+    if value is None:
+        return ""
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, float) and value.is_integer() and abs(value) < 1e21:
+        return str(int(value))
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (list, tuple)):
+        # Array.prototype.toString: elements joined by ',', null/undefined
+        # rendering empty, recursively.
+        return ",".join(_js_string(x) for x in value)
+    if isinstance(value, dict):
+        return "[object Object]"
+    return str(value)
+
+
 def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
     """Coerce a caller value to the declared type.
 
@@ -71,7 +101,7 @@ def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
         return value
 
     if type_ == "string":
-        return value if isinstance(value, str) else str(value)
+        return value if isinstance(value, str) else _js_string(value)
 
     if type_ == "messages":
         if not isinstance(value, list):
@@ -119,7 +149,13 @@ def build_scope(
         # empty. That IS the point of declaring a default -- there is no third
         # case where the caller has to have supplied something, and adding one
         # would turn an empty render into a crash for no gain.
-        if not has or value is None:
+        #
+        # The default applies to an ABSENT key only. An explicit ``None`` is a
+        # value -- "render this empty" -- exactly as ``null`` is in the backend
+        # reference engine and the Node SDK. This engine used to substitute the
+        # default for an explicit ``None``, so the same call rendered different
+        # text in Python than everywhere else, including the playground.
+        if not has:
             value = default if has_default else ([] if type_ == "messages" else "")
 
         scope[name] = _coerce(value, type_, name, errors)

trodo/prompts/template.py

@@ -159,6 +159,21 @@ def _lookup(path: str, scopes: Sequence[Any]) -> Tuple[bool, Any]:
     return False, None
 
 
+def _jsonable(value):
+    """Normalise for JSON.stringify parity: JS has one number type, so a float
+    that is a whole number must serialise as ``1`` and not ``1.0`` -- at any
+    depth. Everything else passes through untouched."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, float) and value.is_integer() and abs(value) < 1e21:
+        return int(value)
+    if isinstance(value, dict):
+        return {k: _jsonable(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_jsonable(v) for v in value]
+    return value
+
+
 def _stringify(value: Any) -> str:
     if value is None:
         return ""
@@ -173,7 +188,7 @@ def _stringify(value: Any) -> str:
             return str(int(value))
         return str(value)
     try:
-        return json.dumps(value, separators=(",", ":"))
+        return json.dumps(_jsonable(value), separators=(",", ":"), ensure_ascii=False)
     except (TypeError, ValueError):
         return str(value)
 

trodo/prompts/types.py

@@ -89,21 +89,30 @@ class ManagedPrompt:
         values = dict(variables or {})
         values.update(kwargs)
         compiled = compile_prompt(self, values)
-        # Prompt traceability: record the exact version compiled so any span
-        # emitted in the surrounding wrap_agent/span scope carries it. No-op
-        # outside a run context. Never records a fallback (no real hash).
+        # Prompt traceability. Never records a fallback — it has no real hash,
+        # so a link to it would name a version that does not exist.
         if not self.is_fallback:
             try:
-                from ..otel.prompt_trace import record_compiled_prompt
-
-                record_compiled_prompt(
-                    {
-                        "name": self.name,
-                        "version_hash": self.version_hash,
-                        "content_hash": self.content_hash,
-                        "label": self.trace_label,
-                    }
+                from ..otel.prompt_trace import (
+                    record_compiled_prompt,
+                    tag_carrier_with_prompt,
                 )
+
+                ref = {
+                    "name": self.name,
+                    "version_hash": self.version_hash,
+                    "content_hash": self.content_hash,
+                    "label": self.trace_label,
+                }
+                # (1) the surrounding run scope, if any — the only route that
+                #     reaches auto-instrumented spans, whose input we never see.
+                record_compiled_prompt(ref)
+                # (2) the compiled value itself, so a span handed these messages
+                #     as ``input`` recovers the version even when compile() ran
+                #     outside the run. Both the wrapper and the list are tagged,
+                #     since callers pass one or the other.
+                tag_carrier_with_prompt(compiled, ref)
+                tag_carrier_with_prompt(getattr(compiled, "messages", None), ref)
             except Exception:  # noqa: BLE001
                 pass  # traceability must never break compile
         return compiled

{trodo_python-2.21.0.dist-info → trodo_python-2.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.21.0
+Version: 2.23.0
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side

{trodo_python-2.21.0.dist-info → trodo_python-2.23.0.dist-info}/RECORD

@@ -16,18 +16,18 @@ trodo/managers/people_manager.py,sha256=mMVnx40Mlifx6NGgChvohC9ViK6dQu2mkXNHbV8p
 trodo/managers/prompt_manager.py,sha256=qFVHgh7PW-SlgHp62ybirdYsJBg-fcQVMTTU3jPqFvo,13435
 trodo/managers/user_manager.py,sha256=faJYX3CHrD7ulYiShV7FhThSMX9aJ3kdOgU4Qtdy5FM,2844
 trodo/otel/__init__.py,sha256=yiRFXWUU45bAM2CV37XeO7zf1hmnmjufdP4XO50yEyE,624
-trodo/otel/auto_instrument.py,sha256=Iae9A9lvh2PImE6gqnyEMXeRPRpjTxZcxx1zW2KDLac,21467
+trodo/otel/auto_instrument.py,sha256=kcfajnmaVuX_giLYBr2P7GiWk-lzZt-iniY8rJEALYw,21819
 trodo/otel/context.py,sha256=Jd0aTc0Q-1dM5kXXinhZD8YtnpdKgvneNiODyboVGKY,1418
 trodo/otel/helpers.py,sha256=XOMWcgZHaq5SQbkFxDaXPE4CDFjn01xjJmJ1vIxvwpw,20730
 trodo/otel/processor.py,sha256=LKlXxP3BeQ7DP8SzYAgXZZOeJ6-6b7e43i19gCUC_0Y,7939
-trodo/otel/prompt_trace.py,sha256=BIrdLOpsR1_HoaCmWb_706GwZSs-UG3p76fjvX3CX3w,3391
+trodo/otel/prompt_trace.py,sha256=X-8AIfwMmegOZl9yMifUkpYu1rV4wE6-kuYYtts0wgA,6184
 trodo/otel/register.py,sha256=bV_ePTfUvPugig2GZnylhzxi2QfoPWs96A9mGLPMrSQ,9387
 trodo/otel/transport.py,sha256=hzZz8gwSMGJ8CxdijmLn1Ljt18owr9XTWy13DLbwYbw,2441
-trodo/otel/wrap_agent.py,sha256=ipMKpdgRF5ibgjDlt2yTBPqbwb8Hq30C7o3hms0QAdU,41987
+trodo/otel/wrap_agent.py,sha256=Izty1jxF4ANVqS72L0CR9jmMuW372AApaEO_0LC5Thw,43860
 trodo/prompts/__init__.py,sha256=yunNc8WkTSfEEkRR-NZWXAt_ZB3Ee2INRh-4RE7uHj4,806
-trodo/prompts/compile.py,sha256=fAYq55LdGIvglNVCnBF3YXyM8W9raLku1M8OAzaQExE,7135
-trodo/prompts/template.py,sha256=obQiivPCR6LEdz7q1cby7uL25tYHYui4aoEaiUNqWfs,9357
-trodo/prompts/types.py,sha256=A24njy6qcc8QNzWEfGu28BbBr360S7A5Pw7_ObIWNS4,4684
+trodo/prompts/compile.py,sha256=XoKDKz6Yaofhrk-87AVW-SnwbiXLvfp161AL2bAFzNY,8802
+trodo/prompts/template.py,sha256=eGO2ZVNOw6JK7Ffj1UCYDMJFYyX5qQW2POlmFJSQpAo,9975
+trodo/prompts/types.py,sha256=OYpaLi1H9pJjeq0gsJo8eb-bWoF8rw2u_7pdukudtqo,5258
 trodo/queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/queue/batch_flusher.py,sha256=4Lg6T3Urwi9U0Q4FpFGPmjDYKg4ZliCTR-ND8BJvWaY,1298
 trodo/queue/event_queue.py,sha256=EVFZrhlq_kwC3jJ2GK0wMhHISf9UzLCZNDnT_aZ2I2A,872
@@ -36,7 +36,7 @@ trodo/session/server_session.py,sha256=McsudEiq33XDq3nqxgzBcUvIjQxCMscwEuAPnYXrT
 trodo/session/session_manager.py,sha256=7ht5LeeZX1HLLfPeNV_a8NkXGbHl3up0CRtCGr3EzjQ,2995
 trodo/util/__init__.py,sha256=Z9c4rPPdKg06Kk3byKheDqksSgR4WNvS475oQ5sNljc,54
 trodo/util/lru.py,sha256=QIsM7s6J_E9ZjiXatSyReZIEeGypTAcgrPWWy8YsRa4,2465
-trodo_python-2.21.0.dist-info/METADATA,sha256=La6v97ZyzSSTa0CeVffS53LhsUvF29mDpm6i92YO63Q,25308
-trodo_python-2.21.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-trodo_python-2.21.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
-trodo_python-2.21.0.dist-info/RECORD,,
+trodo_python-2.23.0.dist-info/METADATA,sha256=HklaG2r4SZNydUnzdRUluF9KLh1d-IszAlS1Sr4UEFI,25308
+trodo_python-2.23.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+trodo_python-2.23.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
+trodo_python-2.23.0.dist-info/RECORD,,