variably-sdk 2.9.0__tar.gz → 2.11.0__tar.gz

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: variably-sdk
-Version: 2.9.0
+Version: 2.11.0
 Summary: Official Python SDK for Variably feature flags, LLM experimentation, and prompt optimization platform
-Author: Variably
 Author-email: Variably <support@variably.com>
 License: MIT
 Project-URL: Homepage, https://github.com/variably/variably-python-sdk
@@ -23,10 +22,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.8
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.25.0
 Requires-Dist: typing-extensions>=3.7.4; python_version < "3.8"
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.1; extra == "langgraph"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.18.0; extra == "dev"
@@ -40,8 +41,6 @@ Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-cov>=2.10; extra == "test"
 Requires-Dist: responses>=0.18.0; extra == "test"
-Dynamic: author
-Dynamic: requires-python
 
 # Variably Python SDK
 

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "variably-sdk"
-version = "2.9.0"
+version = "2.11.0"
 description = "Official Python SDK for Variably feature flags, LLM experimentation, and prompt optimization platform"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -35,6 +35,10 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+# Framework integrations (Task 42.4). Install e.g. `pip install variably-sdk[langgraph]`.
+langgraph = [
+    "langgraph>=0.1",
+]
 dev = [
     "pytest>=6.0",
     "pytest-asyncio>=0.18.0",

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/src/variably/client.py

@@ -678,6 +678,11 @@ class VariablyClient:
         # Multi-turn / Session context
         session_id: Optional[str] = None,          # Groups conversation turns into sessions
         conversation_history: Optional[List[Dict[str, Any]]] = None,  # Prior turns for coherence scoring
+        # Multi-agent context — see docs/improvements/42.1-implementation-plan.md
+        agent_name: Optional[str] = None,          # This step's agent, within a session_id trace
+        is_aggregator: bool = False,               # True on the final step that aggregates the trace
+        tools_called: Optional[List[Dict[str, Any]]] = None,   # [{"name","arguments","output"}] actually called
+        expected_tools: Optional[List[Dict[str, Any]]] = None, # golden tools for deterministic trajectory scoring
         # User & organization context
         user_id: Optional[str] = None,             # End-user ID for per-user analytics
         tags: Optional[List[str]] = None,          # Grouping labels, e.g. ["production", "rag"]
@@ -689,6 +694,8 @@ class VariablyClient:
         prompt_tokens: Optional[int] = None,       # Input token count
         completion_tokens: Optional[int] = None,   # Output token count
         cost: Optional[float] = None,              # Cost in USD
+        # Turn-type marker — see _SUBMIT_RESPONSE_KINDS for allowed values.
+        kind: Optional[str] = None,
     ) -> LogResult:
         """Log a prompt/response pair for multi-dimensional evaluation (Observe Mode).
 
@@ -722,6 +729,45 @@ class VariablyClient:
         # Normalize prompt to string
         prompt_str = prompt if isinstance(prompt, str) else str(prompt)
 
+        # Validate kind and inject the marker into tags + metadata so the
+        # dashboard can suppress grounding/hallucination/attribution
+        # scores on non-generative turns. See submit_response for the
+        # full rationale; the same logic applies in Observe Mode.
+        if kind is not None and kind not in self._SUBMIT_RESPONSE_KINDS:
+            raise ConfigurationError(
+                f"kind must be one of {self._SUBMIT_RESPONSE_KINDS}, got {kind!r}",
+                "kind",
+            )
+        if kind and kind != "generative":
+            kind_tag = f"kind:{kind}"
+            tags = list(tags) if tags else []
+            if kind_tag not in tags:
+                tags.append(kind_tag)
+            metadata = dict(metadata) if metadata else {}
+            metadata.setdefault("kind", kind)
+
+        # Validate multi-agent inputs up front (mirrors server-side checks) so
+        # a malformed trace fails fast at the call site rather than silently
+        # producing an unscoreable session.
+        if is_aggregator and not agent_name:
+            raise ConfigurationError(
+                "is_aggregator=True requires a non-empty agent_name",
+                "agent_name",
+            )
+        if is_aggregator and not session_id:
+            raise ConfigurationError(
+                "is_aggregator=True requires a session_id to assemble the multi-agent trace",
+                "session_id",
+            )
+        for _label, _tools in (("tools_called", tools_called), ("expected_tools", expected_tools)):
+            if _tools:
+                for _t in _tools:
+                    if not isinstance(_t, dict) or not _t.get("name"):
+                        raise ConfigurationError(
+                            f"{_label} entries must be dicts with a non-empty 'name'",
+                            _label,
+                        )
+
         data: Dict[str, Any] = {
             "prompt": prompt_str,
             "response": response,
@@ -744,6 +790,14 @@ class VariablyClient:
             data["user_id"] = user_id
         if session_id:
             data["session_id"] = session_id
+        if agent_name:
+            data["agent_name"] = agent_name
+        if is_aggregator:
+            data["is_aggregator"] = True
+        if tools_called:
+            data["tools_called"] = tools_called
+        if expected_tools:
+            data["expected_tools"] = expected_tools
         if provider:
             data["provider"] = provider
         if model:
@@ -758,6 +812,8 @@ class VariablyClient:
             data["cost"] = cost
         if metadata:
             data["metadata"] = metadata
+        if kind:
+            data["kind"] = kind
 
         try:
             result = self.http_client.log_observation(data)

variably_sdk-2.11.0/src/variably/integrations/__init__.py

@@ -0,0 +1,15 @@
+"""Framework auto-instrumentation for variА/Bly (improvement #42, Task 42.4).
+
+Per-framework integrations that wire multi-agent workflows into variА/Bly's
+deterministic cross-step evaluation with little or no per-node code:
+
+    from variably.integrations.langgraph import instrument
+    instrument(graph, session_id_key="session_id")
+
+Each integration maps the framework's node/agent identity to ``agent_name``,
+detects the terminal node(s) as ``is_aggregator``, pulls session id + context
+from the framework's state, and logs via ``variably.observe`` — always
+best-effort, never raising into the customer's workflow.
+
+Install extras per framework, e.g. ``pip install variably-sdk[langgraph]``.
+"""

variably_sdk-2.11.0/src/variably/integrations/_common.py

@@ -0,0 +1,88 @@
+"""Shared helpers for variА/Bly framework integrations (Task 42.4).
+
+Best-effort extraction of the fields the evaluator needs (response text, an
+optional query/prompt, and the session id) from a framework's state / node
+return value. Everything here is defensive: extraction never raises, so a
+framework whose state shape we don't recognise degrades to an empty string
+rather than breaking the customer's workflow.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, Optional
+
+# Keys we look for when extracting a human-readable response from a node's
+# return value, in priority order.
+_RESPONSE_KEYS = ("response", "output", "answer", "result", "text", "content")
+# Keys we look for when extracting the user query/prompt from graph state.
+_QUERY_KEYS = ("query", "question", "input", "prompt", "user_input")
+
+
+def warn(msg: str) -> None:
+    print(f"[variably.integrations] {msg}", file=sys.stderr)
+
+
+def _message_text(msgs: Any) -> str:
+    """Extract text from a LangChain-style messages list (or single message)."""
+    try:
+        last = msgs[-1] if isinstance(msgs, (list, tuple)) and msgs else msgs
+        content = getattr(last, "content", None)
+        if isinstance(content, str):
+            return content
+        if isinstance(last, dict) and isinstance(last.get("content"), str):
+            return last["content"]
+    except Exception:
+        pass
+    return ""
+
+
+def extract_response_text(update: Any) -> str:
+    """Best-effort extraction of response text from a node's return value."""
+    try:
+        if update is None:
+            return ""
+        if isinstance(update, str):
+            return update
+        if isinstance(update, dict):
+            for k in _RESPONSE_KEYS:
+                v = update.get(k)
+                if isinstance(v, str) and v.strip():
+                    return v
+            if "messages" in update:
+                text = _message_text(update["messages"])
+                if text:
+                    return text
+            for v in update.values():  # fallback: first non-empty string
+                if isinstance(v, str) and v.strip():
+                    return v
+            return ""
+        # objects: try common attributes
+        for k in _RESPONSE_KEYS:
+            v = getattr(update, k, None)
+            if isinstance(v, str) and v.strip():
+                return v
+        return str(update)
+    except Exception:
+        return ""
+
+
+def extract_query(state: Any) -> str:
+    """Best-effort extraction of the user query/prompt from graph state."""
+    try:
+        get = state.get if isinstance(state, dict) else (lambda k, d=None: getattr(state, k, d))
+        for k in _QUERY_KEYS:
+            v = get(k)
+            if isinstance(v, str) and v.strip():
+                return v
+    except Exception:
+        pass
+    return ""
+
+
+def extract_session_id(state: Any, key: str) -> Optional[str]:
+    try:
+        v = state.get(key) if isinstance(state, dict) else getattr(state, key, None)
+        return str(v) if v else None
+    except Exception:
+        return None

variably_sdk-2.11.0/src/variably/integrations/langgraph.py

@@ -0,0 +1,202 @@
+"""LangGraph auto-instrumentation for variА/Bly (Task 42.4).
+
+Two entry points:
+
+1. ``instrument(graph, session_id_key=...)`` — zero-touch. Call it once after
+   you've added nodes/edges (before ``.compile()``). Wraps every node so each
+   execution logs to variА/Bly: ``agent_name`` = node name, ``is_aggregator``
+   on the graph's terminal node(s), ``session_id`` pulled from graph state.
+
+2. ``@observe_node(...)`` — an explicit per-node decorator. Version-independent
+   and the most robust option if ``instrument`` can't wrap your graph's node
+   representation.
+
+Both are best-effort: instrumentation failures degrade to a stderr warning and
+NEVER raise into your graph. Targets langgraph >= 0.1; call ``instrument`` after
+``add_node`` / ``add_edge`` and before ``compile()``.
+"""
+
+from __future__ import annotations
+
+import functools
+from typing import Any, Callable, Iterable, Optional
+
+from variably import observe as _observe
+from variably.integrations._common import (
+    extract_query,
+    extract_response_text,
+    extract_session_id,
+    warn,
+)
+
+
+def _log_node(
+    name: str,
+    state: Any,
+    update: Any,
+    *,
+    is_aggregator: bool,
+    session_id_key: str,
+    response_extractor: Optional[Callable[[Any], str]],
+) -> None:
+    """Log one node execution to variА/Bly. Never raises."""
+    try:
+        resp = (response_extractor or extract_response_text)(update)
+        sid = extract_session_id(state, session_id_key)
+        # is_aggregator requires a session_id (SDK write-time rule); only claim
+        # it when we actually have one, else it degrades to a normal step.
+        agg = bool(is_aggregator and sid)
+        _observe(
+            prompt=extract_query(state) or f"[node:{name}]",
+            response=resp or "",
+            session_id=sid,
+            agent_name=name,
+            is_aggregator=agg,
+        )
+    except Exception as e:  # pragma: no cover - defensive
+        warn(f"node '{name}' instrumentation failed: {e}")
+
+
+def observe_node(
+    *,
+    agent_name: Optional[str] = None,
+    is_aggregator: bool = False,
+    session_id_key: str = "session_id",
+    response_extractor: Optional[Callable[[Any], str]] = None,
+) -> Callable[[Callable], Callable]:
+    """Decorator for a LangGraph node function. Logs the node's output to
+    variА/Bly after it runs. ``agent_name`` defaults to the function name."""
+
+    def decorate(fn: Callable) -> Callable:
+        name = agent_name or getattr(fn, "__name__", "node")
+
+        @functools.wraps(fn)
+        def wrapper(state, *args, **kwargs):
+            update = fn(state, *args, **kwargs)
+            _log_node(
+                name, state, update,
+                is_aggregator=is_aggregator,
+                session_id_key=session_id_key,
+                response_extractor=response_extractor,
+            )
+            return update
+
+        return wrapper
+
+    return decorate
+
+
+def _detect_terminal_nodes(graph) -> set:
+    """Terminal nodes = those with an edge to END, plus any with no outgoing
+    edge. Best-effort across langgraph versions."""
+    terminals: set = set()
+    try:
+        try:
+            from langgraph.graph import END
+        except Exception:
+            END = "__end__"
+
+        node_names = set(getattr(graph, "nodes", {}) or {})
+        edges = getattr(graph, "edges", None) or set()
+        has_outgoing: set = set()
+        for edge in edges:
+            try:
+                u, v = edge
+            except Exception:
+                continue
+            has_outgoing.add(u)
+            if v == END or v == "__end__":
+                terminals.add(u)
+        # nodes with no outgoing plain edge (may route via conditional branches,
+        # but this is a reasonable default when no END edge is declared)
+        terminals |= (node_names - has_outgoing)
+    except Exception as e:  # pragma: no cover - defensive
+        warn(f"terminal-node detection failed: {e}")
+    return terminals
+
+
+def _wrap_callable(name, fn, is_agg, session_id_key, response_extractor):
+    @functools.wraps(fn)
+    def wrapped(state, *args, **kwargs):
+        update = fn(state, *args, **kwargs)
+        _log_node(
+            name, state, update,
+            is_aggregator=is_agg,
+            session_id_key=session_id_key,
+            response_extractor=response_extractor,
+        )
+        return update
+    return wrapped
+
+
+def instrument(
+    graph,
+    *,
+    session_id_key: str = "session_id",
+    aggregator_nodes: Optional[Iterable[str]] = None,
+    response_extractor: Optional[Callable[[Any], str]] = None,
+):
+    """Instrument every node in a LangGraph ``StateGraph`` in place.
+
+    Args:
+        graph: an uncompiled ``StateGraph``.
+        session_id_key: state key holding the session/thread id.
+        aggregator_nodes: override terminal-node auto-detection with an explicit set.
+        response_extractor: custom fn to pull response text from a node's return.
+
+    Returns the same graph (for chaining). Best-effort; never raises.
+    """
+    nodes = getattr(graph, "nodes", None)
+    if not nodes:
+        warn("graph has no .nodes — nothing to instrument (pass an uncompiled StateGraph)")
+        return graph
+
+    terminals = set(aggregator_nodes) if aggregator_nodes is not None else _detect_terminal_nodes(graph)
+
+    for name in list(nodes.keys()):
+        is_agg = name in terminals
+        try:
+            spec = nodes[name]
+            # langgraph StateNodeSpec exposes the node fn on .runnable; older /
+            # simpler representations store the callable directly.
+            runnable = getattr(spec, "runnable", None)
+            if runnable is not None:
+                inner = getattr(runnable, "func", None) or runnable
+                if not callable(inner):
+                    warn(f"node '{name}': runnable is not callable; skipped")
+                    continue
+                wrapped = _wrap_callable(name, inner, is_agg, session_id_key, response_extractor)
+                if hasattr(runnable, "func"):
+                    try:
+                        runnable.func = wrapped  # RunnableCallable/Lambda
+                        continue
+                    except Exception:
+                        pass
+                if _replace_spec_runnable(nodes, name, spec, wrapped):
+                    continue
+                warn(f"node '{name}': could not rewrap runnable (unsupported spec)")
+            elif callable(spec):
+                nodes[name] = _wrap_callable(name, spec, is_agg, session_id_key, response_extractor)
+            else:
+                warn(f"node '{name}': unrecognised spec type {type(spec).__name__}; skipped")
+        except Exception as e:  # pragma: no cover - defensive
+            warn(f"failed to instrument node '{name}': {e}")
+
+    return graph
+
+
+def _replace_spec_runnable(nodes, name, spec, wrapped) -> bool:
+    """Try to put `wrapped` back onto the node spec across spec representations."""
+    # settable attribute
+    try:
+        spec.runnable = wrapped  # type: ignore[attr-defined]
+        return True
+    except Exception:
+        pass
+    # namedtuple-style: rebuild via _replace
+    try:
+        nodes[name] = spec._replace(runnable=wrapped)  # type: ignore[attr-defined]
+        return True
+    except Exception:
+        pass
+    return False

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/src/variably/observe.py

@@ -172,11 +172,33 @@ def observe(
     # Advanced: not needed if you pass session_id (variA/Bly auto-builds history from previous turns).
     prior_turns: Optional[List[Dict[str, str]]] = None,
 
+    # --- Multi-agent context ---
+    # Turn the session_id grouping into an evaluatable multi-agent trace.
+    # agent_name labels which agent produced this step; set is_aggregator=True
+    # on the final step that produces the aggregated answer to trigger
+    # deterministic cross-step scoring (coherence + trajectory).
+    agent_name: Optional[str] = None,
+    is_aggregator: bool = False,
+    # Tools this step actually called / was expected to call. Each dict:
+    # {"name": "...", "arguments": {...}, "output": "..."}. Enables the
+    # deterministic trajectory precision/recall + tool-correctness metrics.
+    tools_called: Optional[List[Dict[str, Any]]] = None,
+    expected_tools: Optional[List[Dict[str, Any]]] = None,
+
     # --- User & organization context ---
     user_id: Optional[str] = None,            # Your end-user's ID — enables per-user analytics
     tags: Optional[List[str]] = None,         # Grouping labels, e.g. ["production", "rag", "v2"]
     metadata: Optional[Dict[str, Any]] = None,  # Any arbitrary key-value data for filtering
 
+    # --- Turn type ---
+    # Marks what kind of LLM turn this is. Use "classifier" / "router" /
+    # "tool_use" / "transformer" for non-generative turns so the dashboard
+    # suppresses grounding/hallucination/attribution scores (which don't
+    # apply to JSON control structures or function calls). Default
+    # "generative" preserves existing behavior.
+    # Allowed: "generative" (default), "classifier", "router", "tool_use", "transformer".
+    kind: Optional[str] = None,
+
     # --- Backward compatibility ---
     conversation_history: Optional[List[Dict[str, str]]] = None,  # Deprecated: use prior_turns instead
 ) -> Optional[Dict[str, Any]]:
@@ -262,7 +284,12 @@ def observe(
             tags=tags,
             user_id=user_id,
             session_id=session_id,
+            agent_name=agent_name,
+            is_aggregator=is_aggregator,
+            tools_called=tools_called,
+            expected_tools=expected_tools,
             metadata=metadata,
+            kind=kind,
         )
 
         return {

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/src/variably/version.py

@@ -1,3 +1,3 @@
 """Version information for Variably SDK."""
 
-__version__ = "2.9.0"
+__version__ = "2.11.0"

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/src/variably_sdk.egg-info/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: variably-sdk
-Version: 2.9.0
+Version: 2.11.0
 Summary: Official Python SDK for Variably feature flags, LLM experimentation, and prompt optimization platform
-Author: Variably
 Author-email: Variably <support@variably.com>
 License: MIT
 Project-URL: Homepage, https://github.com/variably/variably-python-sdk
@@ -23,10 +22,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet :: WWW/HTTP
-Requires-Python: >=3.8
+Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.25.0
 Requires-Dist: typing-extensions>=3.7.4; python_version < "3.8"
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.1; extra == "langgraph"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.18.0; extra == "dev"
@@ -40,8 +41,6 @@ Provides-Extra: test
 Requires-Dist: pytest>=6.0; extra == "test"
 Requires-Dist: pytest-cov>=2.10; extra == "test"
 Requires-Dist: responses>=0.18.0; extra == "test"
-Dynamic: author
-Dynamic: requires-python
 
 # Variably Python SDK
 

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/src/variably_sdk.egg-info/SOURCES.txt

@@ -1,6 +1,5 @@
 README.md
 pyproject.toml
-setup.py
 src/variably/__init__.py
 src/variably/cache.py
 src/variably/client.py
@@ -11,9 +10,13 @@ src/variably/logger.py
 src/variably/observe.py
 src/variably/types.py
 src/variably/version.py
+src/variably/integrations/__init__.py
+src/variably/integrations/_common.py
+src/variably/integrations/langgraph.py
 src/variably_sdk.egg-info/PKG-INFO
 src/variably_sdk.egg-info/SOURCES.txt
 src/variably_sdk.egg-info/dependency_links.txt
 src/variably_sdk.egg-info/requires.txt
 src/variably_sdk.egg-info/top_level.txt
+tests/test_integrations_langgraph.py
 tests/test_streaming.py

{variably_sdk-2.9.0 → variably_sdk-2.11.0}/src/variably_sdk.egg-info/requires.txt

@@ -13,6 +13,9 @@ mypy>=0.800
 isort>=5.0
 responses>=0.18.0
 
+[langgraph]
+langgraph>=0.1
+
 [test]
 pytest>=6.0
 pytest-cov>=2.10

variably_sdk-2.11.0/tests/test_integrations_langgraph.py

@@ -0,0 +1,131 @@
+"""Tests for the LangGraph integration (Task 42.4).
+
+Uses a fake StateGraph and a captured `observe` so no real langgraph is needed.
+"""
+
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
+
+import variably.integrations.langgraph as lg
+from variably.integrations.langgraph import instrument, observe_node
+
+
+class FakeGraph:
+    """Minimal StateGraph stand-in: nodes as name->callable, edges as a set."""
+    def __init__(self):
+        self.nodes = {}
+        self.edges = set()
+
+    def add_node(self, name, fn):
+        self.nodes[name] = fn
+
+    def add_edge(self, u, v):
+        self.edges.add((u, v))
+
+
+def _capture(monkeypatch):
+    calls = []
+    monkeypatch.setattr(lg, "_observe", lambda **kw: calls.append(kw))
+    return calls
+
+
+def test_observe_node_decorator(monkeypatch):
+    calls = _capture(monkeypatch)
+
+    @observe_node(agent_name="reco", is_aggregator=True)
+    def node(state):
+        return {"response": "final recommendation"}
+
+    out = node({"session_id": "s1", "query": "what to buy?"})
+    assert out == {"response": "final recommendation"}
+    assert len(calls) == 1
+    c = calls[0]
+    assert c["agent_name"] == "reco"
+    assert c["is_aggregator"] is True
+    assert c["session_id"] == "s1"
+    assert c["response"] == "final recommendation"
+    assert c["prompt"] == "what to buy?"
+
+
+def test_is_aggregator_requires_session_id(monkeypatch):
+    calls = _capture(monkeypatch)
+
+    @observe_node(agent_name="reco", is_aggregator=True)
+    def node(state):
+        return {"response": "x"}
+
+    node({})  # no session_id
+    assert calls[0]["is_aggregator"] is False
+    assert calls[0]["session_id"] is None
+
+
+def test_instrument_wraps_all_nodes_and_marks_terminal(monkeypatch):
+    calls = _capture(monkeypatch)
+    g = FakeGraph()
+    g.add_node("profiler", lambda s: {"profile": "eco-friendly"})
+    g.add_node("recommender", lambda s: {"response": "buy X"})
+    g.add_edge("profiler", "recommender")
+    g.add_edge("recommender", "__end__")  # terminal
+
+    instrument(g, session_id_key="session_id")
+
+    state = {"session_id": "sess", "query": "q"}
+    g.nodes["profiler"](state)
+    g.nodes["recommender"](state)
+
+    by_agent = {c["agent_name"]: c for c in calls}
+    assert set(by_agent) == {"profiler", "recommender"}
+    assert by_agent["profiler"]["is_aggregator"] is False
+    assert by_agent["recommender"]["is_aggregator"] is True
+    assert by_agent["profiler"]["response"] == "eco-friendly"
+    assert by_agent["recommender"]["response"] == "buy X"
+
+
+def test_instrument_never_breaks_node_when_logging_fails(monkeypatch):
+    def boom(**kw):
+        raise RuntimeError("logging down")
+    monkeypatch.setattr(lg, "_observe", boom)
+
+    g = FakeGraph()
+    g.add_node("n", lambda s: {"response": "still works"})
+    instrument(g)
+    # node must still return its update even though logging raises
+    assert g.nodes["n"]({"session_id": "s"}) == {"response": "still works"}
+
+
+def test_instrument_rewraps_runnable_spec(monkeypatch):
+    calls = _capture(monkeypatch)
+
+    class FakeRunnable:
+        def __init__(self, func):
+            self.func = func
+
+    class Spec:
+        def __init__(self, runnable):
+            self.runnable = runnable
+
+    g = FakeGraph()
+    g.nodes["x"] = Spec(FakeRunnable(lambda s: {"response": "r"}))
+    g.add_edge("x", "__end__")
+
+    instrument(g)
+    # the wrapped fn now lives on .runnable.func
+    g.nodes["x"].runnable.func({"session_id": "s"})
+    assert len(calls) == 1
+    assert calls[0]["agent_name"] == "x"
+    assert calls[0]["is_aggregator"] is True
+
+
+def test_explicit_aggregator_override(monkeypatch):
+    calls = _capture(monkeypatch)
+    g = FakeGraph()
+    g.add_node("a", lambda s: {"response": "1"})
+    g.add_node("b", lambda s: {"response": "2"})
+    instrument(g, aggregator_nodes={"a"})
+    g.nodes["a"]({"session_id": "s"})
+    g.nodes["b"]({"session_id": "s"})
+    by_agent = {c["agent_name"]: c for c in calls}
+    assert by_agent["a"]["is_aggregator"] is True
+    assert by_agent["b"]["is_aggregator"] is False

variably_sdk-2.9.0/setup.py

@@ -1,23 +0,0 @@
-from setuptools import setup, find_packages
-
-setup(
-    name="variably",
-    version="2.4.0",
-    description="Variably Python SDK for LLM experimentation platform",
-    author="Variably",
-    packages=find_packages(),
-    install_requires=[
-        "requests>=2.25.0",
-    ],
-    python_requires=">=3.8",
-    classifiers=[
-        "Development Status :: 4 - Beta",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-    ],
-)