agentevals-cli 0.5.2__py3-none-any.whl

agentevals/trace_attrs.py

@@ -0,0 +1,32 @@
+"""Centralized OTel span attribute key constants.
+
+Single source of truth for all attribute names used across the converter,
+extraction, streaming, and runner modules.
+"""
+
+# OTel scope
+OTEL_SCOPE = "otel.scope.name"
+OTEL_SCOPE_VERSION = "otel.scope.version"
+
+# Google ADK scope value
+ADK_SCOPE_VALUE = "gcp.vertex.agent"
+
+# Standard OTel GenAI semantic conventions (gen_ai.*)
+OTEL_GENAI_OP = "gen_ai.operation.name"
+OTEL_GENAI_AGENT_NAME = "gen_ai.agent.name"
+OTEL_GENAI_REQUEST_MODEL = "gen_ai.request.model"
+OTEL_GENAI_INPUT_MESSAGES = "gen_ai.input.messages"
+OTEL_GENAI_OUTPUT_MESSAGES = "gen_ai.output.messages"
+OTEL_GENAI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens"
+OTEL_GENAI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens"
+OTEL_GENAI_TOOL_NAME = "gen_ai.tool.name"
+OTEL_GENAI_TOOL_CALL_ID = "gen_ai.tool.call.id"
+OTEL_GENAI_TOOL_CALL_ARGUMENTS = "gen_ai.tool.call.arguments"
+OTEL_GENAI_TOOL_CALL_RESULT = "gen_ai.tool.call.result"
+
+# ADK-specific custom attributes (gcp.vertex.agent.*)
+ADK_LLM_REQUEST = "gcp.vertex.agent.llm_request"
+ADK_LLM_RESPONSE = "gcp.vertex.agent.llm_response"
+ADK_TOOL_CALL_ARGS = "gcp.vertex.agent.tool_call_args"
+ADK_TOOL_RESPONSE = "gcp.vertex.agent.tool_response"
+ADK_INVOCATION_ID = "gcp.vertex.agent.invocation_id"

agentevals/trace_metrics.py

@@ -0,0 +1,126 @@
+"""Extract performance and metadata from trace spans."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .extraction import (
+    extract_agent_response_from_attrs,
+    extract_token_usage_from_attrs,
+    extract_user_text_from_attrs,
+    get_extractor,
+)
+from .trace_attrs import OTEL_GENAI_AGENT_NAME, OTEL_GENAI_REQUEST_MODEL
+
+
+def _truncate(text: str, max_length: int = 200) -> str:
+    if len(text) <= max_length:
+        return text
+    return text[:max_length] + "..."
+
+
+def _calc_percentiles(values: list[float]) -> dict[str, float]:
+    if not values:
+        return {"p50": 0.0, "p95": 0.0, "p99": 0.0}
+    import statistics
+
+    sorted_values = sorted(values)
+    n = len(sorted_values)
+    return {
+        "p50": statistics.median(sorted_values),
+        "p95": sorted_values[int(n * 0.95)] if n > 1 else sorted_values[0],
+        "p99": sorted_values[int(n * 0.99)] if n > 1 else sorted_values[0],
+    }
+
+
+def extract_performance_metrics(trace, extractor=None) -> dict[str, Any]:
+    """Extract latency and token usage metrics from trace spans."""
+    agent_latencies = []
+    llm_latencies = []
+    tool_latencies = []
+    prompt_tokens = []
+    output_tokens = []
+    total_tokens = []
+
+    if extractor is None:
+        extractor = get_extractor(trace)
+    invocation_spans = extractor.find_invocation_spans(trace)
+
+    if not invocation_spans and trace.root_spans:
+        for root_span in trace.root_spans:
+            agent_latencies.append(root_span.duration / 1000.0)
+
+    for inv_span in invocation_spans:
+        agent_latencies.append(inv_span.duration / 1000.0)
+
+    for span in trace.all_spans:
+        duration_ms = span.duration / 1000.0
+        role = extractor.classify_span(span)
+
+        if role == "llm":
+            llm_latencies.append(duration_ms)
+            in_toks, out_toks, _ = extract_token_usage_from_attrs(span.tags)
+            if in_toks or out_toks:
+                prompt_tokens.append(in_toks)
+                output_tokens.append(out_toks)
+                total_tokens.append(in_toks + out_toks)
+        elif role == "tool":
+            tool_latencies.append(duration_ms)
+
+    return {
+        "latency": {
+            "overall": _calc_percentiles(agent_latencies),
+            "llm_calls": _calc_percentiles(llm_latencies),
+            "tool_executions": _calc_percentiles(tool_latencies),
+        },
+        "tokens": {
+            "total_prompt": sum(prompt_tokens) if prompt_tokens else 0,
+            "total_output": sum(output_tokens) if output_tokens else 0,
+            "total": sum(total_tokens) if total_tokens else 0,
+            "per_llm_call": _calc_percentiles(total_tokens) if total_tokens else {"p50": 0.0, "p95": 0.0, "p99": 0.0},
+        },
+    }
+
+
+def extract_trace_metadata(trace, extractor=None) -> dict[str, Any]:
+    """Extract agent name, model, timing, and preview text from a trace."""
+    metadata: dict[str, Any] = {
+        "agent_name": None,
+        "model": None,
+        "start_time": None,
+        "user_input_preview": None,
+        "final_output_preview": None,
+    }
+
+    if extractor is None:
+        extractor = get_extractor(trace)
+    invocation_spans = extractor.find_invocation_spans(trace)
+
+    if invocation_spans:
+        first_inv = invocation_spans[0]
+        metadata["agent_name"] = first_inv.get_tag(OTEL_GENAI_AGENT_NAME)
+        metadata["start_time"] = first_inv.start_time
+
+        llm_spans = extractor.find_llm_spans_in(first_inv)
+        if llm_spans:
+            metadata["model"] = llm_spans[0].get_tag(OTEL_GENAI_REQUEST_MODEL)
+
+            user_text = extract_user_text_from_attrs(llm_spans[0].tags)
+            if user_text:
+                metadata["user_input_preview"] = _truncate(user_text)
+
+            agent_text = extract_agent_response_from_attrs(llm_spans[-1].tags)
+            if agent_text:
+                metadata["final_output_preview"] = _truncate(agent_text)
+
+    if not metadata["agent_name"] and trace.root_spans:
+        metadata["agent_name"] = trace.root_spans[0].operation_name
+
+    if not metadata["model"]:
+        for span in trace.all_spans:
+            model = span.get_tag(OTEL_GENAI_REQUEST_MODEL)
+            if model:
+                metadata["model"] = model
+                break
+
+    return metadata

agentevals/utils/genai_messages.py

@@ -0,0 +1,142 @@
+"""Utilities for parsing OTel GenAI semantic convention message formats.
+
+Supports two message formats:
+- Content-based (e.g. opentelemetry-instrumentation-openai-v2):
+    {"role": "user", "content": "Hello"}
+    {"role": "assistant", "content": "...", "tool_calls": [{"type": "function", ...}]}
+
+- Parts-based (OTel GenAI semconv v1.36.0+):
+    {"role": "user", "parts": [{"type": "text", "content": "Hello"}]}
+    {"role": "assistant", "parts": [{"type": "tool_call", "name": "...", "arguments": {...}}]}
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+USER_ROLES = ("user", "human")
+ASSISTANT_ROLES = ("assistant", "model", "ai")
+
+
+def parse_json_attr(raw: str | dict | list | Any, tag_name: str = "") -> dict | list | Any:
+    """Parse a JSON string from an OTel span attribute value.
+
+    If *raw* is already a dict or list it is returned as-is.
+    Returns ``{}`` on parse failure.
+    """
+    if isinstance(raw, (dict, list)):
+        return raw
+    if isinstance(raw, str):
+        try:
+            return json.loads(raw)
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse JSON in %s: %s", tag_name, raw[:200])
+            return {}
+    return {}
+
+
+def extract_text_from_message(msg: dict) -> str:
+    """Extract text content from a GenAI message in any supported format."""
+    content = msg.get("content")
+    if isinstance(content, str) and content:
+        return content
+    if isinstance(content, list):
+        parts = [item["text"] for item in content if isinstance(item, dict) and "text" in item]
+        if parts:
+            return " ".join(parts)
+
+    parts = msg.get("parts")
+    if isinstance(parts, list):
+        text_parts = []
+        for part in parts:
+            if not isinstance(part, dict) or part.get("type") != "text":
+                continue
+            text = part.get("content") or part.get("text", "")
+            if text:
+                text_parts.append(text)
+        if text_parts:
+            return " ".join(text_parts)
+
+    return ""
+
+
+def extract_tool_calls_from_message(msg: dict) -> list[dict[str, Any]]:
+    """Extract tool calls from a GenAI message in any supported format.
+
+    Returns a normalized list of:
+        {"name": str, "id": str | None, "arguments": dict}
+    """
+    result = []
+
+    tool_calls = msg.get("tool_calls")
+    if isinstance(tool_calls, list):
+        for tc in tool_calls:
+            if not isinstance(tc, dict):
+                continue
+            if tc.get("type") == "function" and "function" in tc:
+                func = tc["function"]
+                args = _parse_args(func.get("arguments", {}))
+                result.append(
+                    {
+                        "name": func.get("name", ""),
+                        "id": tc.get("id"),
+                        "arguments": args,
+                    }
+                )
+
+    if not result:
+        parts = msg.get("parts")
+        if isinstance(parts, list):
+            for part in parts:
+                if not isinstance(part, dict) or part.get("type") != "tool_call":
+                    continue
+                args = _parse_args(part.get("arguments", {}))
+                result.append(
+                    {
+                        "name": part.get("name", ""),
+                        "id": part.get("id"),
+                        "arguments": args,
+                    }
+                )
+
+    return result
+
+
+def extract_tool_call_args_from_messages(
+    messages_raw: str | list | Any,
+    tool_name: str,
+) -> tuple[dict, str | None]:
+    """Fallback: extract tool call args and ID from a messages attribute by matching *tool_name*.
+
+    Used when a tool span lacks ``gen_ai.tool.call.arguments`` directly
+    (e.g. Strands embeds the triggering tool_call in ``gen_ai.input.messages``).
+
+    Returns ``(args_dict, tool_call_id_or_None)``.
+    """
+    messages = parse_json_attr(messages_raw, "gen_ai.input.messages")
+    if not isinstance(messages, list):
+        return {}, None
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        for tc in extract_tool_calls_from_message(msg):
+            if tc["name"] == tool_name and tc["arguments"]:
+                return tc["arguments"], tc.get("id")
+    return {}, None
+
+
+def _parse_args(args: Any) -> dict:
+    if isinstance(args, dict):
+        return args
+    if isinstance(args, str):
+        try:
+            parsed = json.loads(args)
+            if isinstance(parsed, dict):
+                return parsed
+        except json.JSONDecodeError:
+            logger.warning("Failed to parse tool call arguments JSON: %s", args[:200])
+    return {}

agentevals/utils/log_buffer.py

@@ -0,0 +1,43 @@
+import logging
+from collections import deque
+from dataclasses import dataclass
+from datetime import UTC
+
+
+@dataclass
+class BufferedLogRecord:
+    timestamp: str
+    level: str
+    logger_name: str
+    message: str
+    exc_text: str | None = None
+
+
+class RingBufferLogHandler(logging.Handler):
+    def __init__(self, capacity: int = 1000):
+        super().__init__()
+        self._buffer: deque[BufferedLogRecord] = deque(maxlen=capacity)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        from datetime import datetime
+
+        self._buffer.append(
+            BufferedLogRecord(
+                timestamp=datetime.fromtimestamp(record.created, tz=UTC).isoformat(),
+                level=record.levelname,
+                logger_name=record.name,
+                message=self.format(record),
+                exc_text=record.exc_text,
+            )
+        )
+
+    def get_text(self) -> str:
+        lines = []
+        for r in self._buffer:
+            lines.append(f"[{r.timestamp}] {r.level} {r.logger_name}: {r.message}")
+            if r.exc_text:
+                lines.append(r.exc_text)
+        return "\n".join(lines)
+
+
+log_buffer = RingBufferLogHandler(capacity=1000)

agentevals/utils/log_enrichment.py

@@ -0,0 +1,187 @@
+"""Utilities for enriching OTel spans with GenAI log message content."""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections import defaultdict
+
+from ..trace_attrs import (
+    OTEL_GENAI_AGENT_NAME,
+    OTEL_GENAI_INPUT_MESSAGES,
+    OTEL_GENAI_OUTPUT_MESSAGES,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def enrich_spans_with_logs(spans: list[dict], logs: list[dict], session_id: str | None = None) -> list[dict]:
+    """Enrich spans with message content from GenAI logs.
+
+    This reconstructs gen_ai.input.messages and gen_ai.output.messages attributes
+    from log events so the converter can extract message content.
+
+    When logs carry a ``span_id`` (OTLP path), each span is enriched only with
+    its own logs. When logs lack ``span_id`` (WebSocket SDK path), all messages
+    are injected into every span (legacy behavior).
+
+    Args:
+        spans: List of OTLP span dictionaries
+        logs: List of GenAI log event dictionaries
+        session_id: Optional session ID to add as agent.name attribute
+
+    Returns:
+        List of enriched span dictionaries with message attributes added
+    """
+    if not logs:
+        return spans
+
+    logger.debug("Enriching %d spans with %d logs", len(spans), len(logs))
+
+    has_span_ids = any(log.get("span_id") for log in logs)
+
+    if has_span_ids:
+        return _enrich_per_span(spans, logs, session_id)
+    return _enrich_broadcast(spans, logs, session_id)
+
+
+def _extract_messages_from_logs(
+    logs: list[dict],
+) -> tuple[list[dict], list[dict]]:
+    """Extract deduplicated input/output messages from a list of log events."""
+    input_messages = []
+    output_messages = []
+    seen_user = set()
+    seen_assistant = set()
+
+    for log in logs:
+        event_name = log.get("event_name", "")
+        body = log.get("body", {})
+
+        if not isinstance(body, dict):
+            continue
+
+        if event_name == "gen_ai.user.message":
+            user_content = body.get("content", "")
+            if user_content and user_content not in seen_user:
+                input_messages.append({"role": "user", "content": user_content})
+                seen_user.add(user_content)
+
+        elif event_name in ("gen_ai.assistant.message", "gen_ai.choice"):
+            if event_name == "gen_ai.choice":
+                nested = body.get("message", {}) if isinstance(body.get("message"), dict) else {}
+                assistant_content = body.get("content") or nested.get("content") or ""
+                tool_calls = nested.get("tool_calls", [])
+            else:
+                assistant_content = body.get("content") or ""
+                tool_calls = body.get("tool_calls", [])
+
+            message_key = f"{assistant_content}:{json.dumps(tool_calls) if tool_calls else ''}"
+
+            if (assistant_content or tool_calls) and message_key not in seen_assistant:
+                assistant_msg = {"role": "assistant", "content": assistant_content}
+                if tool_calls:
+                    assistant_msg["tool_calls"] = tool_calls
+                output_messages.append(assistant_msg)
+                seen_assistant.add(message_key)
+
+    return input_messages, output_messages
+
+
+def _inject_messages(
+    span: dict,
+    input_messages: list[dict],
+    output_messages: list[dict],
+    session_id: str | None,
+) -> dict:
+    """Create a copy of *span* with message attributes injected."""
+    span_copy = span.copy()
+    attrs = list(span_copy.get("attributes", []))
+    span_copy["attributes"] = attrs
+
+    if input_messages:
+        attrs.append(
+            {
+                "key": OTEL_GENAI_INPUT_MESSAGES,
+                "value": {"stringValue": json.dumps(input_messages)},
+            }
+        )
+    if output_messages:
+        attrs.append(
+            {
+                "key": OTEL_GENAI_OUTPUT_MESSAGES,
+                "value": {"stringValue": json.dumps(output_messages)},
+            }
+        )
+    if session_id:
+        attrs.append(
+            {
+                "key": OTEL_GENAI_AGENT_NAME,
+                "value": {"stringValue": session_id},
+            }
+        )
+
+    return span_copy
+
+
+def _enrich_per_span(
+    spans: list[dict],
+    logs: list[dict],
+    session_id: str | None,
+) -> list[dict]:
+    """Enrich each span with only the logs emitted within that span's context."""
+    logs_by_span: dict[str, list[dict]] = defaultdict(list)
+    for log in logs:
+        sid = log.get("span_id", "")
+        if sid:
+            logs_by_span[sid].append(log)
+
+    enriched = []
+    for span in spans:
+        span_id = span.get("spanId", "")
+        span_logs = logs_by_span.get(span_id, [])
+
+        if span_logs:
+            input_msgs, output_msgs = _extract_messages_from_logs(span_logs)
+            enriched.append(_inject_messages(span, input_msgs, output_msgs, session_id))
+        else:
+            span_copy = span.copy()
+            if session_id:
+                attrs = list(span_copy.get("attributes", []))
+                attrs.append(
+                    {
+                        "key": OTEL_GENAI_AGENT_NAME,
+                        "value": {"stringValue": session_id},
+                    }
+                )
+                span_copy["attributes"] = attrs
+            enriched.append(span_copy)
+
+    matched = sum(1 for sid in logs_by_span if any(s.get("spanId") == sid for s in spans))
+    logger.debug(
+        "Per-span enrichment: %d log groups, %d matched to spans",
+        len(logs_by_span),
+        matched,
+    )
+    return enriched
+
+
+def _enrich_broadcast(
+    spans: list[dict],
+    logs: list[dict],
+    session_id: str | None,
+) -> list[dict]:
+    """Legacy enrichment: inject all messages into every span."""
+    input_messages, output_messages = _extract_messages_from_logs(logs)
+
+    if not (input_messages or output_messages):
+        logger.warning("No messages extracted from logs")
+        return spans
+
+    logger.debug(
+        "Broadcast enrichment: %d user, %d assistant messages",
+        len(input_messages),
+        len(output_messages),
+    )
+
+    return [_inject_messages(span, input_messages, output_messages, session_id) for span in spans]

agentevals_cli-0.5.2.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: agentevals-cli
+Version: 0.5.2
+Summary: Standalone framework to evaluate agent correctness based on portable OpenTelemetry traces
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: google-adk[eval]>=1.25.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: opentelemetry-proto>=1.36.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: python-multipart>=0.0.12
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: uvicorn[standard]>=0.32.0
+Provides-Extra: live
+Requires-Dist: httpx>=0.27.0; extra == 'live'
+Requires-Dist: mcp>=1.26.0; extra == 'live'
+Provides-Extra: streaming
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == 'streaming'
+Requires-Dist: websockets>=12.0; extra == 'streaming'

agentevals_cli-0.5.2.dist-info/RECORD

@@ -0,0 +1,46 @@
+agentevals/__init__.py,sha256=NU0vD23WlyU5pexvoOMAsCuFvbJ-OJ9rfoJcnRl72dc,448
+agentevals/_protocol.py,sha256=IHqAdPBp76boK_PQU_oFIvRDjZ0hehOyv75tyHIceAI,2578
+agentevals/builtin_metrics.py,sha256=UQF8Gwthbvg-43YrVlULhGOb98qM11SnAezW7nD1-_Q,7944
+agentevals/cli.py,sha256=8asqKXD4BN9Tf97ounqaOcHLEwc85tzKy7kvcjUiYM0,20231
+agentevals/config.py,sha256=G1x2xIjkS3LGHLbDtCHXihiTP2ORYnFczLX4R-X0MwI,3383
+agentevals/converter.py,sha256=TMF8zHTwgULjtq-F7CQt78uHB28YZPOxQQp2jpmcpWg,11377
+agentevals/custom_evaluators.py,sha256=cBTPnxVVP7YHNdBXuoN3uGtNWFky46Cf2MbAf2tc3cM,15875
+agentevals/eval_config_loader.py,sha256=cQOxu4VoUEmrCGe4srV9zWqF0-wrHmLUr-Jo8eF9znc,4908
+agentevals/extraction.py,sha256=whCTbP0mzxx1aIBYKCNU99-z2_tJzGHhYUMjOKs35UU,16735
+agentevals/genai_converter.py,sha256=d3n5LpAr84eMpdve5tDNXDl-THN66I6Y8YCDM3vfQ5E,20399
+agentevals/mcp_server.py,sha256=bZVfrGqyYdjuxoF-bN22CS4R6J0Vj_ct3gBYc_cbxe8,9395
+agentevals/output.py,sha256=KvmNpIPIMKp1VwuBv31nwNxaXRGR679_nSNJpCn5ehs,7263
+agentevals/runner.py,sha256=5BI9sDNgmsHhR6welq6cS9yaT2LG6p3ULXNS4cNTZQI,11050
+agentevals/sdk.py,sha256=5sXtmiIGonMyHeTdO04GKdFPZB5yeSG1jCarKTQ86wM,15796
+agentevals/trace_attrs.py,sha256=fJ5PjRNjhbD0r-SPHKhOwX_oEFyjUViVLjus1HOsEnw,1263
+agentevals/trace_metrics.py,sha256=WpLgDB1Z_b6LmpkwknK0rxxcc-wmbZfocBtN97_g_uk,4266
+agentevals/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentevals/api/app.py,sha256=LBFUVcMrqwFLtpimqQLp1GCkVxibxLKEZ1I3SQB8Hzg,4088
+agentevals/api/debug_routes.py,sha256=vrSjqUAShsO6WQh0OqX2ZtcJeVAV5DPuaK-k5_sYULg,9093
+agentevals/api/models.py,sha256=caYsK7vj7Cpb6Juhr4UbJU1nkvqG_5CbGw4NOVbjJ5s,4451
+agentevals/api/otlp_app.py,sha256=N6qtNY0_vX5N5WLrQ7fXi8EspM6CcOgS32nFoVmT6uU,605
+agentevals/api/otlp_routes.py,sha256=QJRZW_jt-HZ47aUax94pxUhphMa25qPGza5bJfwIiSo,14165
+agentevals/api/routes.py,sha256=nE3bEt1Tzm37UyMoMhGl1oRyq5lR2C_7xmNWrUz6Yx0,20987
+agentevals/api/streaming_routes.py,sha256=Uj88WXzvFbOq4xA0FYa7t2NsyWpnCORvXQiqQtCYiWI,13167
+agentevals/evaluator/__init__.py,sha256=_4n0uxBA6LcEGOuIfn6nTbFGD32O2llfxStOxTU2Lis,574
+agentevals/evaluator/resolver.py,sha256=AXo6kBpvLfIq2ZLXfckNI58AixrMv7KYJaffb-yyBgg,2529
+agentevals/evaluator/sources.py,sha256=SJ2MIAwrtmgtdnGscqC-9MjUp76jKBQUwnX-1rWUkBk,9591
+agentevals/evaluator/templates.py,sha256=1kqcdhdmNsTotJlMydbZsvM8Tmgm4JXXa1B6B7MspwY,4914
+agentevals/loader/__init__.py,sha256=EpnM_rHm7v17hDDzBUT3JzfuAqEZdHT5jJ8_z3jnayc,202
+agentevals/loader/base.py,sha256=OTeoEyHbvUEbwzsYzuRHeK8Sx7fuLTafd9T4UI7cGSk,1503
+agentevals/loader/jaeger.py,sha256=DgN7CJdN2w4OGONye90HIeUtYTv-vu9gFNesCAI9ULo,3568
+agentevals/loader/otlp.py,sha256=alShML5ukryFKgt85VC1Nc6U69hK3zH7tcL36IcwP6w,7194
+agentevals/streaming/__init__.py,sha256=WnAeBETNIK9KcA47vAQnL7s8WPFgknQLdy4laknGm9E,3939
+agentevals/streaming/incremental_processor.py,sha256=b2DEf1SgyHT8EHcFeAhhiNYwpE039d8GYcw49guAsP4,14550
+agentevals/streaming/processor.py,sha256=gXwwKzEzR6vWokKR2AIhnaQYYYmcE6Jk_fcBYMLonks,10886
+agentevals/streaming/session.py,sha256=vUWzqq1CQigpkiDEqJqDM9LTyLw0Q39DilYy1Yw0XZE,1210
+agentevals/streaming/ws_server.py,sha256=kkdavfBrcCoo5vnVz_FHAWZ2lARU6g9mSy41y5XChrc,32872
+agentevals/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentevals/utils/genai_messages.py,sha256=BURKS3eoUQzmiwMuYPznv9IDwUKyzsiCI4klUlBTPVM,4704
+agentevals/utils/log_buffer.py,sha256=bpDCPvfwBC2ZzOXXh0bmcbq3bSc1JixTSJZf9XqvG_M,1188
+agentevals/utils/log_enrichment.py,sha256=SmhQknMoz3Pkbg0Rz1J83B1if74Qfh2rthrP6O21bD4,6117
+agentevals_cli-0.5.2.dist-info/METADATA,sha256=SxxDY7HJtYtn7wqxUKM01RN4memFgtQcAAy6BsL5nq0,802
+agentevals_cli-0.5.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+agentevals_cli-0.5.2.dist-info/entry_points.txt,sha256=lLyvQGvs92BySjju70F7byMFSAb9LTexKmSkwF4jkks,51
+agentevals_cli-0.5.2.dist-info/licenses/LICENSE,sha256=Ox7lseFP2kBRXBjsLweW1jLmWiCyrKjwF8ZUvCbKd70,11310
+agentevals_cli-0.5.2.dist-info/RECORD,,

agentevals_cli-0.5.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agentevals_cli-0.5.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agentevals = agentevals.cli:main