zeno-cli 0.3.4__py3-none-any.whl

zeno_adapters/__init__.py

@@ -0,0 +1,17 @@
+"""Adapter package exports."""
+
+from .anthropic import instrument as instrument_anthropic
+from .claude_code import instrument as instrument_claude_code
+from .crewai import instrument_agent as instrument_crewai_agent
+from .crewai import instrument_crew as instrument_crewai_crew
+from .langgraph import instrument as instrument_langgraph
+from .openai import instrument as instrument_openai
+
+__all__ = [
+    "instrument_anthropic",
+    "instrument_claude_code",
+    "instrument_crewai_agent",
+    "instrument_crewai_crew",
+    "instrument_langgraph",
+    "instrument_openai",
+]

zeno_adapters/_common.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import Any
+
+
+def _get(obj: Any, key: str, default: Any = None) -> Any:
+    if isinstance(obj, dict):
+        return obj.get(key, default)
+    return getattr(obj, key, default)
+
+
+def _tool_names_from_anthropic(result: Any) -> list[str]:
+    content = _get(result, "content", [])
+    names: list[str] = []
+    for item in content or []:
+        if _get(item, "type") == "tool_use":
+            name = _get(item, "name")
+            if isinstance(name, str):
+                names.append(name)
+    return names
+
+
+def _extract_usage(result: Any) -> tuple[int | None, int | None]:
+    usage = _get(result, "usage")
+    if usage is None:
+        return (None, None)
+    input_tokens = _get(usage, "input_tokens")
+    output_tokens = _get(usage, "output_tokens")
+    return (input_tokens, output_tokens)
+
+
+def call_with_timing(fn: Callable[..., Any], *args: Any, **kwargs: Any) -> tuple[Any, int]:
+    started = time.perf_counter_ns()
+    result = fn(*args, **kwargs)
+    latency_ms = int((time.perf_counter_ns() - started) / 1_000_000)
+    return result, max(latency_ms, 0)

zeno_adapters/anthropic.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ._common import _extract_usage, _tool_names_from_anthropic, call_with_timing
+
+
+@dataclass(slots=True)
+class _MessagesProxy:
+    inner: Any
+    zeno_session: Any
+    record_content: bool = False
+
+    def create(self, *args: Any, **kwargs: Any) -> Any:
+        model = kwargs.get("model", "unknown")
+        with self.zeno_session.agent_run(model=model) as run:
+            try:
+                result, latency_ms = call_with_timing(self.inner.create, *args, **kwargs)
+                input_tokens, output_tokens = _extract_usage(result)
+                metadata: dict[str, Any] = {
+                    "provider": "anthropic",
+                    "harness": "anthropic",
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                    "tool_names": _tool_names_from_anthropic(result),
+                    "tool_call_count": len(_tool_names_from_anthropic(result)),
+                }
+                if self.record_content:
+                    metadata["prompt"] = str(kwargs.get("messages"))
+                    metadata["output"] = str(getattr(result, "content", None))
+
+                self.zeno_session.record(
+                    type="accept",
+                    latency_ms_to_decide=latency_ms,
+                    metadata=metadata,
+                )
+                run.outcome("accepted")
+                return result
+            except Exception:
+                self.zeno_session.record(
+                    type="reject",
+                    metadata={"provider": "anthropic", "harness": "anthropic"},
+                )
+                run.outcome("rejected")
+                raise
+
+
+@dataclass(slots=True)
+class _ClientProxy:
+    client: Any
+    zeno_session: Any
+    record_content: bool = False
+
+    @property
+    def messages(self) -> _MessagesProxy:
+        return _MessagesProxy(
+            inner=self.client.messages,
+            zeno_session=self.zeno_session,
+            record_content=self.record_content,
+        )
+
+    def __getattr__(self, item: str) -> Any:
+        return getattr(self.client, item)
+
+
+def instrument(client: Any, *, zeno_session: Any, record_content: bool = False) -> Any:
+    return _ClientProxy(client=client, zeno_session=zeno_session, record_content=record_content)

zeno_adapters/claude_code.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ._common import _extract_usage, _tool_names_from_anthropic, call_with_timing
+
+
+def _trace_metadata(tracer: Any) -> dict[str, Any]:
+    if tracer is None:
+        return {"trace_event_count": 0, "trace_event_types": []}
+    events = tracer.get_recent_events()
+    event_types = sorted(
+        {
+            event.get("type")
+            for event in events
+            if isinstance(event, dict) and isinstance(event.get("type"), str)
+        }
+    )
+    return {
+        "trace_event_count": len(events),
+        "trace_event_types": event_types,
+    }
+
+
+@dataclass(slots=True)
+class _MessagesProxy:
+    inner: Any
+    tracer: Any
+    zeno_session: Any
+    record_content: bool = False
+
+    def create(self, *args: Any, **kwargs: Any) -> Any:
+        model = kwargs.get("model", "unknown")
+        with self.zeno_session.agent_run(model=model) as run:
+            try:
+                result, latency_ms = call_with_timing(self.inner.create, *args, **kwargs)
+                input_tokens, output_tokens = _extract_usage(result)
+                tool_names = _tool_names_from_anthropic(result)
+                metadata: dict[str, Any] = {
+                    "provider": "anthropic",
+                    "harness": "claude-code",
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                    "tool_names": tool_names,
+                    "tool_call_count": len(tool_names),
+                }
+                metadata.update(_trace_metadata(self.tracer))
+                if self.record_content:
+                    metadata["prompt"] = str(kwargs.get("messages"))
+                    metadata["output"] = str(getattr(result, "content", None))
+
+                self.zeno_session.record(
+                    type="accept",
+                    latency_ms_to_decide=latency_ms,
+                    metadata=metadata,
+                )
+                run.outcome("accepted")
+                return result
+            except Exception:
+                self.zeno_session.record(
+                    type="reject",
+                    metadata={"provider": "anthropic", "harness": "claude-code"},
+                )
+                run.outcome("rejected")
+                raise
+
+
+@dataclass(slots=True)
+class _ClientProxy:
+    client: Any
+    tracer: Any
+    zeno_session: Any
+    record_content: bool = False
+
+    @property
+    def messages(self) -> _MessagesProxy:
+        return _MessagesProxy(
+            inner=self.client.messages,
+            tracer=self.tracer,
+            zeno_session=self.zeno_session,
+            record_content=self.record_content,
+        )
+
+    def __getattr__(self, item: str) -> Any:
+        return getattr(self.client, item)
+
+
+def instrument(
+    client: Any,
+    *,
+    tracer: Any,
+    zeno_session: Any,
+    record_content: bool = False,
+) -> Any:
+    return _ClientProxy(
+        client=client,
+        tracer=tracer,
+        zeno_session=zeno_session,
+        record_content=record_content,
+    )

zeno_adapters/crewai.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ._common import call_with_timing
+
+
+@dataclass(slots=True)
+class InstrumentedAgent:
+    inner: Any
+    zeno_session: Any
+    model: str = "crewai-agent"
+    record_content: bool = False
+
+    def run(self, *args: Any, **kwargs: Any) -> Any:
+        with self.zeno_session.agent_run(model=self.model) as run:
+            try:
+                result, latency_ms = call_with_timing(self.inner.run, *args, **kwargs)
+                metadata: dict[str, Any] = {
+                    "provider": "crewai",
+                    "harness": "crewai",
+                    "tool_call_count": int(getattr(result, "tool_call_count", 0)),
+                    "tool_names": list(getattr(result, "tool_names", [])),
+                    "status": getattr(result, "status", "success"),
+                }
+                if self.record_content:
+                    metadata["prompt"] = str(kwargs.get("task") or kwargs.get("input"))
+                    metadata["output"] = str(getattr(result, "output", None))
+                self.zeno_session.record(
+                    type="accept",
+                    latency_ms_to_decide=latency_ms,
+                    metadata=metadata,
+                )
+                run.outcome("accepted")
+                return result
+            except Exception:
+                self.zeno_session.record(
+                    type="reject",
+                    metadata={"provider": "crewai", "harness": "crewai"},
+                )
+                run.outcome("rejected")
+                raise
+
+    def __getattr__(self, item: str) -> Any:
+        return getattr(self.inner, item)
+
+
+@dataclass(slots=True)
+class InstrumentedCrew:
+    inner: Any
+    zeno_session: Any
+    model: str = "crewai-crew"
+    record_content: bool = False
+
+    def kickoff(self, *args: Any, **kwargs: Any) -> Any:
+        with self.zeno_session.agent_run(model=self.model) as run:
+            try:
+                result, latency_ms = call_with_timing(self.inner.kickoff, *args, **kwargs)
+                metadata: dict[str, Any] = {
+                    "provider": "crewai",
+                    "harness": "crewai",
+                    "status": "kickoff",
+                }
+                if self.record_content:
+                    metadata["prompt"] = str(kwargs.get("inputs"))
+                    metadata["output"] = str(result)
+                self.zeno_session.record(
+                    type="accept",
+                    latency_ms_to_decide=latency_ms,
+                    metadata=metadata,
+                )
+                run.outcome("accepted")
+                return result
+            except Exception:
+                self.zeno_session.record(
+                    type="reject",
+                    metadata={"provider": "crewai", "harness": "crewai"},
+                )
+                run.outcome("rejected")
+                raise
+
+    def __getattr__(self, item: str) -> Any:
+        return getattr(self.inner, item)
+
+
+def instrument_agent(agent: Any, *, zeno_session: Any, record_content: bool = False) -> Any:
+    return InstrumentedAgent(inner=agent, zeno_session=zeno_session, record_content=record_content)
+
+
+def instrument_crew(crew: Any, *, zeno_session: Any, record_content: bool = False) -> Any:
+    return InstrumentedCrew(inner=crew, zeno_session=zeno_session, record_content=record_content)

zeno_adapters/langgraph.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ._common import call_with_timing
+
+
+@dataclass(slots=True)
+class InstrumentedGraph:
+    inner: Any
+    zeno_session: Any
+    model: str = "langgraph"
+    record_content: bool = False
+
+    def invoke(self, *args: Any, **kwargs: Any) -> Any:
+        with self.zeno_session.agent_run(model=self.model) as run:
+            try:
+                result, latency_ms = call_with_timing(self.inner.invoke, *args, **kwargs)
+                metadata: dict[str, Any] = {
+                    "provider": "langgraph",
+                    "harness": "langgraph",
+                    "node_count": int(getattr(result, "node_count", 0)),
+                    "tool_call_count": int(getattr(result, "tool_call_count", 0)),
+                }
+                if self.record_content:
+                    metadata["prompt"] = str(kwargs.get("input") or args[0] if args else "")
+                    metadata["output"] = str(result)
+                self.zeno_session.record(
+                    type="accept",
+                    latency_ms_to_decide=latency_ms,
+                    metadata=metadata,
+                )
+                run.outcome("accepted")
+                return result
+            except Exception:
+                self.zeno_session.record(
+                    type="reject",
+                    metadata={"provider": "langgraph", "harness": "langgraph"},
+                )
+                run.outcome("rejected")
+                raise
+
+    def __getattr__(self, item: str) -> Any:
+        return getattr(self.inner, item)
+
+
+def instrument(graph: Any, *, zeno_session: Any, record_content: bool = False) -> Any:
+    return InstrumentedGraph(inner=graph, zeno_session=zeno_session, record_content=record_content)

zeno_adapters/openai.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from ._common import _extract_usage, call_with_timing
+
+
+def _tool_names_from_openai(result: Any) -> list[str]:
+    tool_names: list[str] = []
+    output = getattr(result, "output", None)
+    if output is None and isinstance(result, dict):
+        output = result.get("output")
+    for item in output or []:
+        item_type = item.get("type") if isinstance(item, dict) else getattr(item, "type", None)
+        if item_type == "tool_call":
+            name = item.get("name") if isinstance(item, dict) else getattr(item, "name", None)
+            if isinstance(name, str):
+                tool_names.append(name)
+    return tool_names
+
+
+@dataclass(slots=True)
+class _CreateProxy:
+    inner: Any
+    zeno_session: Any
+    provider: str
+    record_content: bool = False
+
+    def create(self, *args: Any, **kwargs: Any) -> Any:
+        model = kwargs.get("model", "unknown")
+        with self.zeno_session.agent_run(model=model) as run:
+            try:
+                result, latency_ms = call_with_timing(self.inner.create, *args, **kwargs)
+                input_tokens, output_tokens = _extract_usage(result)
+                tool_names = _tool_names_from_openai(result)
+                metadata: dict[str, Any] = {
+                    "provider": "openai",
+                    "harness": self.provider,
+                    "input_tokens": input_tokens,
+                    "output_tokens": output_tokens,
+                    "tool_names": tool_names,
+                    "tool_call_count": len(tool_names),
+                }
+                if self.record_content:
+                    metadata["prompt"] = str(kwargs.get("messages") or kwargs.get("input"))
+                    metadata["output"] = str(getattr(result, "output", None))
+                self.zeno_session.record(
+                    type="accept",
+                    latency_ms_to_decide=latency_ms,
+                    metadata=metadata,
+                )
+                run.outcome("accepted")
+                return result
+            except Exception:
+                self.zeno_session.record(
+                    type="reject",
+                    metadata={"provider": "openai", "harness": self.provider},
+                )
+                run.outcome("rejected")
+                raise
+
+
+@dataclass(slots=True)
+class _ChatProxy:
+    inner: Any
+    zeno_session: Any
+    record_content: bool = False
+
+    @property
+    def completions(self) -> _CreateProxy:
+        return _CreateProxy(
+            inner=self.inner.completions,
+            zeno_session=self.zeno_session,
+            provider="openai-chat",
+            record_content=self.record_content,
+        )
+
+
+@dataclass(slots=True)
+class _ClientProxy:
+    client: Any
+    zeno_session: Any
+    record_content: bool = False
+
+    @property
+    def responses(self) -> _CreateProxy:
+        return _CreateProxy(
+            inner=self.client.responses,
+            zeno_session=self.zeno_session,
+            provider="openai-responses",
+            record_content=self.record_content,
+        )
+
+    @property
+    def chat(self) -> _ChatProxy:
+        return _ChatProxy(
+            inner=self.client.chat,
+            zeno_session=self.zeno_session,
+            record_content=self.record_content,
+        )
+
+    def __getattr__(self, item: str) -> Any:
+        return getattr(self.client, item)
+
+
+def instrument(client: Any, *, zeno_session: Any, record_content: bool = False) -> Any:
+    return _ClientProxy(client=client, zeno_session=zeno_session, record_content=record_content)

zeno_cli/__init__.py

@@ -0,0 +1 @@
+"""Zeno CLI package placeholder."""