trodo-python 2.18.0__tar.gz → 2.18.2__tar.gz

{trodo_python-2.18.0 → trodo_python-2.18.2}/PKG-INFO

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

{trodo_python-2.18.0 → trodo_python-2.18.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trodo-python"
-version = "2.18.0"
+version = "2.18.2"
 description = "Trodo Analytics SDK for Python — server-side event tracking"
 readme = "README.md"
 license = { text = "ISC" }

trodo_python-2.18.2/tests/test_get_prompt_version_types.py

@@ -0,0 +1,54 @@
+"""The public get_prompt must accept a version_hash, not just an int.
+
+The manager has always taken ``Union[int, str]`` and documents hash support —
+the hash is the stable identity the dashboard shows and the SDK returns. But
+the top-level ``trodo.get_prompt`` wrapper narrowed the hint to ``int``, so a
+type checker flagged the documented usage, and the dashboard's own "Use this
+prompt" snippet emits ``version="<hash>"`` for Python.
+
+Checked by signature rather than by a network call: the wrapper only forwards,
+so the contract IS the signature.
+"""
+import inspect
+import typing
+
+import trodo
+from trodo.managers.prompt_manager import PromptManager
+
+
+def _version_annotation(fn):
+    return typing.get_type_hints(fn)["version"]
+
+
+def test_public_get_prompt_accepts_int_or_str():
+    ann = _version_annotation(trodo.get_prompt)
+    args = typing.get_args(ann)
+    assert int in args, f"version should accept int, got {ann}"
+    assert str in args, f"version should accept a version_hash (str), got {ann}"
+
+
+def test_matches_the_manager_it_forwards_to():
+    assert _version_annotation(trodo.get_prompt) == _version_annotation(PromptManager.get)
+
+
+def test_forwards_version_through_untouched():
+    """A hash must reach the manager as-is — not coerced, not dropped."""
+    seen = {}
+
+    class _Stub:
+        def get(self, name, **kwargs):
+            seen.update(kwargs, name=name)
+            return "sentinel"
+
+    class _Client:
+        prompts = _Stub()
+
+    original = trodo._get_client
+    trodo._get_client = lambda: _Client()
+    try:
+        assert trodo.get_prompt("p", version="a3f9c2") == "sentinel"
+    finally:
+        trodo._get_client = original
+
+    assert seen["version"] == "a3f9c2"
+    assert seen["label"] is None

trodo_python-2.18.2/tests/test_multi_agent_shape.py

@@ -0,0 +1,106 @@
+"""Multi-agent run shape — one run, sub-agents as ``agent``-kind child spans.
+
+The shape the ``trodo-tracing`` skill teaches: a request that fans out to
+sub-agents produces ONE run whose tree carries an ``agent`` span per sub-agent,
+with each sub-agent's own work nested underneath it. The failure mode this
+guards against is a ``wrap_agent`` per sub-agent, which shatters one request
+into N disconnected runs and loses whole-request cost, latency and the
+delegation tree.
+
+Also covers the module-level ``user`` / ``parent_run_id`` kwargs, which the
+skill's guidance writes and which the top-level wrappers used to silently drop.
+"""
+
+from __future__ import annotations
+
+import inspect
+
+import trodo
+from trodo.otel.wrap_agent import span as span_ctx
+from trodo.otel.wrap_agent import wrap_agent as wrap_agent_ctx
+
+
+def _tree(payload):
+    """{span_id: (name, kind, parent_span_id)} for one ingested run payload."""
+    return {s["span_id"]: (s["name"], s["kind"], s["parent_span_id"]) for s in payload["spans"]}
+
+
+def test_sub_agents_nest_as_agent_spans_in_one_run(processor, http):
+    """A supervisor with two workers and a writer = 1 run, 3 agent spans."""
+    with wrap_agent_ctx(
+        processor=processor, team_site_id="site", agent_name="research_assistant",
+        distinct_id="u_1", conversation_id="thread_1",
+    ) as run:
+        run.set_input([{"role": "user", "content": "why did revenue drop"}])
+
+        with span_ctx("planner", kind="agent") as s:
+            s.set_output({"subtasks": ["pricing", "churn"]})
+
+        for topic in ("pricing", "churn"):
+            with span_ctx(f"researcher:{topic}", kind="agent") as s:
+                s.set_attribute("topic", topic)
+                # The sub-agent's own tool call nests under the sub-agent, not the run.
+                with span_ctx("web_search", kind="tool") as t:
+                    t.set_tool("web_search")
+                    t.set_output({"hits": 3})
+                s.set_output({"topic": topic})
+
+        run.set_output({"answer": "pricing change in March"})
+
+    # Exactly ONE run — not one per sub-agent.
+    assert len(http.run_ingest) == 1
+    payload = http.run_ingest[0]
+    assert payload["run"]["agent_name"] == "research_assistant"
+    assert payload["run"]["conversation_id"] == "thread_1"
+
+    tree = _tree(payload)
+    by_name = {v[0]: (sid, v[1], v[2]) for sid, v in tree.items()}
+
+    # Three agent-kind sub-agent spans, all siblings directly under the run root.
+    parents = set()
+    for name in ("planner", "researcher:pricing", "researcher:churn"):
+        sid, kind, parent = by_name[name]
+        assert kind == "agent", f"{name} should be an agent span, got {kind}"
+        parents.add(parent)
+    assert len(parents) == 1, "sub-agents should be siblings under one run root"
+
+    # Each tool span nests under its own researcher, preserving the delegation tree.
+    tool_parents = {v[2] for sid, v in tree.items() if v[1] == "tool"}
+    researcher_ids = {by_name[n][0] for n in ("researcher:pricing", "researcher:churn")}
+    assert tool_parents == researcher_ids
+
+    # The run rolls up the whole request, which is the point of keeping it one run.
+    assert payload["run"]["span_count"] == 5
+    assert payload["run"]["tool_count"] == 2
+
+
+def test_independently_triggered_sub_agent_links_via_parent_run_id(processor, http):
+    """The other shape: separate runs, linked — for independently-triggered work."""
+    with wrap_agent_ctx(
+        processor=processor, team_site_id="site", agent_name="intake", distinct_id="u_1",
+    ) as parent:
+        parent.set_output({"job": "enrich"})
+
+    with wrap_agent_ctx(
+        processor=processor, team_site_id="site", agent_name="enrichment",
+        distinct_id="u_1", parent_run_id=parent.run_id,
+    ) as child:
+        child.set_output({"done": True})
+
+    assert len(http.run_ingest) == 2
+    assert http.run_ingest[1]["run"]["parent_run_id"] == parent.run_id
+
+
+def test_module_level_wrappers_forward_user_and_parent_run_id():
+    """``trodo.wrap_agent(..., user=...)`` is what the skill tells people to write.
+
+    The module-level wrappers used to drop ``user`` on the floor (and ``agent``
+    also dropped ``parent_run_id``), so the documented call raised TypeError.
+    """
+    for fn, expected in (
+        (trodo.wrap_agent, {"user", "parent_run_id", "conversation_id", "metadata"}),
+        (trodo.agent, {"user", "parent_run_id", "conversation_id", "metadata"}),
+        (trodo.start_run, {"user", "parent_run_id", "conversation_id", "metadata", "input"}),
+    ):
+        params = set(inspect.signature(fn).parameters)
+        assert expected <= params, f"{fn.__name__} is missing {expected - params}"

{trodo_python-2.18.0 → trodo_python-2.18.2}/trodo/__init__.py

@@ -322,7 +322,7 @@ def reset(distinct_id: str) -> ResetResult:
 def get_prompt(
     name: str,
     label: Optional[str] = None,
-    version: Optional[int] = None,
+    version: Optional[Union[int, str]] = None,
     cache_ttl_seconds: Optional[float] = None,
     fallback: Optional[Dict[str, Any]] = None,
     max_retries: int = 2,
@@ -330,7 +330,9 @@ def get_prompt(
     """Fetch a managed prompt by name.
 
     Follows the ``production`` label by default; pass ``label`` for a different
-    one or ``version`` to pin exactly.
+    one or ``version`` to pin exactly. ``version`` may be the integer
+    ``version_no`` or a ``version_hash`` (full, or an unambiguous short prefix
+    like ``a3f9c2``) — the hash is the stable identity, so prefer it.
 
     Cached for 60s with stale-while-revalidate, so a Trodo outage degrades
     instead of taking your app down. Pass ``fallback`` to cover cold start::
@@ -524,14 +526,21 @@ def wrap_agent(
     conversation_id: Optional[str] = None,
     parent_run_id: Optional[str] = None,
     metadata: Optional[Dict[str, Any]] = None,
+    user: Optional[Dict[str, Any]] = None,
 ) -> _wrap_agent_ctx:
-    """Wrap a block as an agent run — returns a context manager yielding RunHandle."""
+    """Wrap a block as an agent run — returns a context manager yielding RunHandle.
+
+    ``user`` carries profile traits alongside the run — ``{"properties": ...,
+    "set_once": ..., "fixed_properties": ...}`` — so a request handler can
+    attribute the run and enrich the profile in one round trip.
+    """
     return _get_client().wrap_agent(
         agent_name,
         distinct_id=distinct_id,
         conversation_id=conversation_id,
         parent_run_id=parent_run_id,
         metadata=metadata,
+        user=user,
     )
 
 
@@ -540,14 +549,18 @@ def agent(
     *,
     distinct_id: Optional[str] = None,
     conversation_id: Optional[str] = None,
+    parent_run_id: Optional[str] = None,
     metadata: Optional[Dict[str, Any]] = None,
+    user: Optional[Dict[str, Any]] = None,
 ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """Decorator form of wrap_agent."""
     return _get_client().agent(
         agent_name,
         distinct_id=distinct_id,
         conversation_id=conversation_id,
+        parent_run_id=parent_run_id,
         metadata=metadata,
+        user=user,
     )
 
 
@@ -591,6 +604,7 @@ def start_run(
     parent_run_id: Optional[str] = None,
     metadata: Optional[Dict[str, Any]] = None,
     input: Any = None,
+    user: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Open a Run record without a context manager.
 
@@ -607,6 +621,7 @@ def start_run(
         parent_run_id=parent_run_id,
         metadata=metadata,
         input=input,
+        user=user,
     )
 
 

{trodo_python-2.18.0 → trodo_python-2.18.2}/trodo/client.py

@@ -357,7 +357,9 @@ class TrodoClient:
         *,
         distinct_id: Optional[str] = None,
         conversation_id: Optional[str] = None,
+        parent_run_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        user: Optional[Dict[str, Any]] = None,
     ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
         """Decorator form of wrap_agent."""
 
@@ -368,7 +370,9 @@ class TrodoClient:
                     agent_name,
                     distinct_id=distinct_id,
                     conversation_id=conversation_id,
+                    parent_run_id=parent_run_id,
                     metadata=metadata,
+                    user=user,
                 ) as run:
                     result = fn(*args, **kwargs)
                     run.set_output(result)

{trodo_python-2.18.0 → trodo_python-2.18.2}/trodo_python.egg-info/PKG-INFO

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

{trodo_python-2.18.0 → trodo_python-2.18.2}/trodo_python.egg-info/SOURCES.txt

@@ -7,7 +7,9 @@ tests/test_datasets.py
 tests/test_end_run.py
 tests/test_error_enrichment.py
 tests/test_experiments.py
+tests/test_get_prompt_version_types.py
 tests/test_llm_usage_cost.py
+tests/test_multi_agent_shape.py
 tests/test_processor_methods.py
 tests/test_prompt_trace.py
 tests/test_prompts.py