trodo-python 2.20.0__py3-none-any.whl → 2.22.0__py3-none-any.whl

trodo/__init__.py

@@ -41,7 +41,7 @@ Downstream microservice (join the caller's run instead of making a new one):
 
 from __future__ import annotations
 
-__version__ = "2.20.0"
+__version__ = "2.21.0"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 

trodo/managers/prompt_manager.py

@@ -38,6 +38,11 @@ __all__ = [
 DEFAULT_TTL_SECONDS = 60.0
 
 
+# 404 bodies that mean "your SELECTOR is wrong", not "the prompt is gone".
+# Mirrors backend/models/prompt.js missReason -- the wire contract's error half.
+_CONFIG_ERROR_CODES = frozenset({"version_not_found", "label_not_found", "no_versions"})
+
+
 def _cache_key(name: str, version: Optional[Union[int, str]], label: Optional[str]) -> str:
     # Resolution happens server-side on every fetch; the client only caches
     # under whatever selector was asked for. So a label flip propagates within
@@ -197,7 +202,14 @@ class PromptManager:
         Availability ladder — fresh cache -> stale cache -> ``fallback`` ->
         raise. A prompt fetch is on your hot path, so a Trodo outage degrades
         rather than takes your app down. Check ``prompt.is_fallback`` to detect
-        the last rung. Pass ``cache_ttl_seconds=0`` to disable caching (handy in
+        the last rung.
+
+        The ladder is for AVAILABILITY failures only. A selector that names
+        nothing — a ``version`` or ``label`` that doesn't exist on a prompt
+        that does — is a config error in your code and raises immediately
+        (``e.code`` is ``version_not_found`` | ``label_not_found`` |
+        ``no_versions``), because being quietly handed the fallback would hide
+        the typo for as long as it ships. Pass ``cache_ttl_seconds=0`` to disable caching (handy in
         development).
 
         :raises ValueError: if *name* is empty, or both ``label`` and ``version``
@@ -224,6 +236,22 @@ class PromptManager:
             if not res or res.get("__error") or not res.get("prompt"):
                 status = res.get("status") if isinstance(res, dict) else None
                 detail = res.get("error") if isinstance(res, dict) else None
+                # The server distinguishes a selector that names nothing from a
+                # prompt that is missing. The first is a CONFIG error -- your
+                # code asks for a version or label that does not exist -- and
+                # must throw through the availability ladder below rather than
+                # be masked by stale content or the fallback.
+                if detail in _CONFIG_ERROR_CODES:
+                    if detail == "version_not_found":
+                        what = f"version {version!r} does not exist on prompt {name!r}"
+                    elif detail == "label_not_found":
+                        what = f"label {label!r} does not exist on prompt {name!r}"
+                    else:
+                        what = f"prompt {name!r} has no versions yet -- save one in the dashboard"
+                    err = LookupError(f"trodo: {what}" + (f" (HTTP {status})" if status else ""))
+                    err.code = detail  # type: ignore[attr-defined]
+                    err.prompt_config_error = True  # type: ignore[attr-defined]
+                    raise err
                 raise LookupError(
                     f"trodo: could not fetch prompt {name!r}"
                     + (f" (HTTP {status})" if status else "")
@@ -248,7 +276,12 @@ class PromptManager:
             if ttl > 0:
                 self._cache.set(key, raw, ttl)
             return _to_prompt(raw, trace_label=trace_label)
-        except Exception:
+        except Exception as e:
+            # A config error is not an outage: a typo'd label silently serving
+            # the fallback forever would hide the mistake for as long as it
+            # ships. Config errors surface.
+            if getattr(e, "prompt_config_error", False):
+                raise
             stale = self._cache.get_stale(key)
             if stale is not None:
                 return _to_prompt(stale, trace_label=trace_label)

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
 
@@ -258,16 +263,44 @@ def _mint_anon_distinct_id() -> str:
     return f"anon_{ts}_python_{uuid.uuid4()}_{rand}"
 
 
+def _tag_error_with_run(exc: object, run_id: Optional[str]) -> None:
+    """Stamp the active run's id onto an exception about to propagate.
+
+    The run IS recorded server-side when an agent raises -- status, error type,
+    full message. What was missing is the join: the exception a developer's
+    error tracker captures had no reference to the recorded run, so the two
+    could only be matched by timestamp. ``exc.trodo_run_id`` is that join.
+
+    Guarded on purpose: exceptions can use ``__slots__`` or be otherwise
+    unwritable, and a crash inside error handling is the one unforgivable
+    failure mode here.
+    """
+    if exc is None or not run_id:
+        return
+    try:
+        exc.trodo_run_id = run_id  # type: ignore[attr-defined]
+    except Exception:  # noqa: BLE001 -- slots/frozen; the run is still recorded
+        pass
+
+
 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
@@ -278,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:
@@ -310,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
@@ -373,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:
@@ -574,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,
@@ -583,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__()
@@ -600,6 +649,7 @@ class wrap_agent:
             einfo = describe_error(exc_type, exc, tb)
             error_summary = einfo["error_message"]
             error_type = einfo["error_type"]
+            _tag_error_with_run(exc, self.handle.run_id)
         elif manual_run_error:
             status = "error"
             error_summary = self.handle.error_summary
@@ -687,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:
@@ -704,6 +759,7 @@ class wrap_agent:
             for k, v in self.handle.metadata.items():
                 otel_span.set_attribute(f"trodo.metadata.{k}", _serialize_attr(v))
             if exc is not None:
+                _tag_error_with_run(exc, self.handle.run_id if self.handle else None)
                 otel_span.record_exception(exc)
                 _, status_cls, status_code = get_otel_helpers()
                 if status_cls is not None and status_code is not None:
@@ -748,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
@@ -764,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)
 
@@ -816,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])
@@ -843,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
@@ -867,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:
@@ -923,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)
@@ -949,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

@@ -8,6 +8,7 @@ or the prompt you tested is not the prompt you shipped.
 
 from __future__ import annotations
 
+import json
 from typing import Any, Dict, List, Optional
 
 from .template import render
@@ -26,6 +27,15 @@ class CompileError(Exception):
         self.details: List[str] = details or []
 
 
+def _q(value: Any) -> str:
+    """Format an offending value the way Node's JSON.stringify does, so the two
+    engines produce byte-identical error text. repr() was the one divergence a
+    full cross-SDK parity run found."""
+    try:
+        return json.dumps(value, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return repr(value)
+
 def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
     """Coerce a caller value to the declared type.
 
@@ -36,15 +46,18 @@ def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
         return value
 
     if type_ == "number":
+        # _q (json.dumps), not repr: the Node engine formats the offending
+        # value with JSON.stringify, and the two engines' error text is
+        # asserted byte-identical.
         if isinstance(value, bool):
-            errors.append(f"variable '{name}': expected a number, got {value!r}")
+            errors.append(f"variable '{name}': expected a number, got {_q(value)}")
             return value
         if isinstance(value, (int, float)):
             return value
         try:
             return float(value) if "." in str(value) else int(value)
         except (TypeError, ValueError):
-            errors.append(f"variable '{name}': expected a number, got {value!r}")
+            errors.append(f"variable '{name}': expected a number, got {_q(value)}")
             return value
 
     if type_ == "boolean":
@@ -54,7 +67,7 @@ def _coerce(value: Any, type_: str, name: str, errors: List[str]) -> Any:
             return True
         if value == "false":
             return False
-        errors.append(f"variable '{name}': expected a boolean, got {value!r}")
+        errors.append(f"variable '{name}': expected a boolean, got {_q(value)}")
         return value
 
     if type_ == "string":

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.20.0.dist-info → trodo_python-2.22.0.dist-info}/METADATA

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

{trodo_python-2.20.0.dist-info → trodo_python-2.22.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-trodo/__init__.py,sha256=ueM-l4KXHdP42DzvCRN9Zc5d4OsCxOSjiT-NIGAiLyQ,26928
+trodo/__init__.py,sha256=yv0gxvU4OpZhqck-U2YY0RZE7qRWDhD4ig4zenbMPI0,26928
 trodo/client.py,sha256=9UYaHZtWPMYdlG2xWVf77PQJ9DfFgN-zobTh60i8_Cc,22453
 trodo/types.py,sha256=eySgUvCXROG2TxtxgiU0MNr5iH0DEcduK8bmYtTKG44,3138
 trodo/user_context.py,sha256=uHCI2WYoOI3cNwdIUEuZdX4VYSu14pzm348ksn6hn_c,8195
@@ -13,21 +13,21 @@ trodo/managers/dataset_manager.py,sha256=gx0S8ujG3cbw4IskBNMdceBjDbcEh_nebwKSzEv
 trodo/managers/experiment_manager.py,sha256=V-vemLtenfSI5VIcP0HPiXzEy8AyTrRrbJVCA9Z6wjo,10579
 trodo/managers/group_manager.py,sha256=ki3Se3qEoSZfREX63oeDeBmEfZF-ISHLE8azEtLg0tM,3542
 trodo/managers/people_manager.py,sha256=mMVnx40Mlifx6NGgChvohC9ViK6dQu2mkXNHbV8pK1E,2882
-trodo/managers/prompt_manager.py,sha256=4xj_38b2qU31aTs5fIq-wNJnPisqf1zre0u8jvjZOF4,11375
+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=cJjrzlZNW2g6q_coLN7UR4uxn65h4u3-LNzMfE4dLVw,40999
+trodo/otel/wrap_agent.py,sha256=Izty1jxF4ANVqS72L0CR9jmMuW372AApaEO_0LC5Thw,43860
 trodo/prompts/__init__.py,sha256=yunNc8WkTSfEEkRR-NZWXAt_ZB3Ee2INRh-4RE7uHj4,806
-trodo/prompts/compile.py,sha256=UhJhu-BtVicaauDEKpAXB17KhgVs4jWos_I60I8kZFk,6583
+trodo/prompts/compile.py,sha256=fAYq55LdGIvglNVCnBF3YXyM8W9raLku1M8OAzaQExE,7135
 trodo/prompts/template.py,sha256=obQiivPCR6LEdz7q1cby7uL25tYHYui4aoEaiUNqWfs,9357
-trodo/prompts/types.py,sha256=A24njy6qcc8QNzWEfGu28BbBr360S7A5Pw7_ObIWNS4,4684
+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.20.0.dist-info/METADATA,sha256=EYdoY1cwgukIxmryCG6QadL0qiIz5J8harU3y7v6Q0Y,25308
-trodo_python-2.20.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-trodo_python-2.20.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
-trodo_python-2.20.0.dist-info/RECORD,,
+trodo_python-2.22.0.dist-info/METADATA,sha256=RmvsK5vGdIvPBMeZqjANQygwnolV11Hb4006GzI6Xcg,25308
+trodo_python-2.22.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+trodo_python-2.22.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
+trodo_python-2.22.0.dist-info/RECORD,,