agentevals-cli 0.9.9__tar.gz → 0.9.10__tar.gz

agentevals_cli-0.9.10/.github/workflows/ci.yml

@@ -0,0 +1,139 @@
+name: CI
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  helm-chart:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Lint + template
+        run: make helm-test
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        with:
+          enable-cache: true
+
+      - name: Verify uv.lock matches pyproject.toml
+        run: uv lock --check
+
+      - name: Install dependencies
+        run: |
+          uv venv
+          uv pip install setuptools
+          uv sync --dev
+
+      - name: Ruff check
+        run: uv run ruff check .
+
+      - name: Ruff format check
+        run: uv run ruff format --check .
+
+  ui:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
+        with:
+          node-version: '22'
+          cache: npm
+          cache-dependency-path: ui/package-lock.json
+
+      # tsc -b && vite build, same as the release workflow bundles.
+      - name: Build UI
+        run: make build-ui
+
+  docker:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      IMAGE_REF: agentevals:ci
+      IMAGE_VERSION: 0.0.0.dev0
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0
+
+      # The release workflow is the only other place this Dockerfile gets built, and it
+      # runs after the GitHub release is already published. Build it here so a break
+      # lands on the PR instead of halfway through a release.
+      # Single-arch keeps it native; the multi-arch build stays release-only because
+      # emulating arm64 through the node and uv layers is an order of magnitude slower.
+      - name: Build image
+        uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0
+        with:
+          context: .
+          platforms: linux/amd64
+          build-args: VERSION=${{ env.IMAGE_VERSION }}
+          tags: ${{ env.IMAGE_REF }}
+          push: false
+          load: true
+          cache-from: type=gha
+          # Pull requests read main's layers but never write, so a branch cannot grow
+          # or displace the cache the other jobs share.
+          cache-to: ${{ github.event_name == 'push' && 'type=gha,mode=max' || '' }}
+
+      - name: Smoke test
+        run: |
+          docker run -d --name agentevals-ci -p 127.0.0.1:8001:8001 "$IMAGE_REF"
+          for _ in $(seq 1 30); do
+            if curl -fsS --max-time 3 http://127.0.0.1:8001/api/health -o "$RUNNER_TEMP/health.json"; then
+              break
+            fi
+            sleep 2
+          done
+          test -s "$RUNNER_TEMP/health.json" || { echo "server never became healthy"; exit 1; }
+          cat "$RUNNER_TEMP/health.json"
+          grep -q '"status":"ok"' "$RUNNER_TEMP/health.json"
+          # Proves the SETUPTOOLS_SCM_PRETEND_VERSION path still resolves; a silent
+          # break there would ship a mis-versioned image.
+          grep -q "\"version\":\"$IMAGE_VERSION\"" "$RUNNER_TEMP/health.json"
+          curl -fsS http://127.0.0.1:8001/ | grep -q '<div id="root">'
+          test "$(docker exec agentevals-ci id -u)" = "1000"
+
+      - name: Container logs
+        if: failure()
+        run: docker logs agentevals-ci
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        with:
+          enable-cache: true
+
+      - name: Install Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          uv venv --python ${{ matrix.python-version }}
+          uv pip install setuptools
+          uv sync --dev --all-extras --frozen --python ${{ matrix.python-version }}
+
+      - name: Run tests
+        run: uv run pytest -m "not integration and not e2e" --tb=short -q

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/Dockerfile

@@ -1,6 +1,6 @@
 # syntax=docker/dockerfile:1
 
-FROM node:25-bookworm-slim AS ui
+FROM node:26-bookworm-slim AS ui
 WORKDIR /build/ui
 COPY ui/package.json ui/package-lock.json ./
 # Skip lifecycle scripts during ci, then rebuild esbuild in its own layer — avoids ETXTBSY when

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/Makefile

@@ -9,13 +9,17 @@ DOCKER_IMAGE_REF := $(if $(DOCKER_REGISTRY),$(DOCKER_REGISTRY:%/=%)/$(DOCKER_IMA
 # Multi-arch build (requires docker buildx). Manifest lists must be pushed — use build-docker-local for a single-arch --load.
 PLATFORMS ?= linux/amd64,linux/arm64
 
+# LOCAL_VERSION falls back to a stub so build-docker-local works without uv or git history.
+LOCAL_VERSION ?= $(if $(VERSION),$(VERSION),0.0.0.dev0)
+LOCAL_TAG ?= local
+
 HELM_REPO ?= oci://ghcr.io/agentevals-dev/agentevals
 HELM_DIST_FOLDER ?= dist/helm
 HELM_CHART_DIR ?= charts/agentevals
 HELM_CHART_OCI_URL ?= $(HELM_REPO)/helm
 HELM_CHART_VERSION ?= $(VERSION)
 
-.PHONY: build build-bundle build-docker build-ui release clean dev-backend dev-backend-pg dev-frontend dev-bundle pg-up pg-down migrate test test-unit test-integration test-e2e helm-lint helm-template helm-test helm-cleanup helm-package helm-publish
+.PHONY: build build-bundle build-docker build-docker-local build-ui release clean dev-backend dev-backend-pg dev-frontend dev-bundle pg-up pg-down migrate test test-unit test-integration test-e2e helm-lint helm-template helm-test helm-cleanup helm-package helm-publish
 
 PG_CONTAINER ?= agentevals-pg
 PG_PORT      ?= 5432
@@ -31,6 +35,9 @@ build-docker:
 	@test -n "$(VERSION)" || { echo "ERROR: VERSION is empty. Pass VERSION=x.y.z explicitly, or install uv so hatch-vcs can resolve it."; exit 1; }
 	docker buildx build --platform $(PLATFORMS) --build-arg VERSION=$(VERSION) -t $(DOCKER_IMAGE_REF):$(DOCKER_TAG) --push .
 
+build-docker-local:
+	docker buildx build --build-arg VERSION=$(LOCAL_VERSION) -t $(DOCKER_IMAGE_REF):$(LOCAL_TAG) --load .
+
 build-ui:
 	cd ui && npm ci && npm run build
 

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentevals-cli
-Version: 0.9.9
+Version: 0.9.10
 Summary: Standalone framework to evaluate agent correctness based on portable OpenTelemetry traces
 License-File: LICENSE
 Requires-Python: >=3.11

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/src/agentevals/api/otlp_processing.py

@@ -15,7 +15,10 @@ from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
 )
 
 from ..extraction import flatten_otlp_attributes
+from ..otlp_anyvalue import decode_any_value
 from ..trace_attrs import (
+    AGENTEVALS_EVAL_SET_ID,
+    AGENTEVALS_SESSION_NAME,
     OTEL_GENAI_CONVERSATION_ID,
     OTEL_GENAI_INPUT_MESSAGES,
     OTEL_GENAI_OUTPUT_MESSAGES,
@@ -30,9 +33,6 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
-AGENTEVALS_EVAL_SET_ID = "agentevals.eval_set_id"
-AGENTEVALS_SESSION_NAME = "agentevals.session_name"
-
 
 async def process_traces(body: dict, manager: StreamingTraceManager) -> None:
     """Parse ExportTraceServiceRequest and feed spans to the pipeline."""
@@ -242,7 +242,13 @@ def _normalize_span(span_data: dict, scope_name: str, scope_version: str, schema
 
 
 def _extract_agentevals_metadata(resource_attrs: list[dict]) -> dict:
-    """Extract agentevals-specific metadata from OTLP resource attributes."""
+    """Extract agentevals-specific metadata from OTLP resource attributes.
+
+    ``eval_set_id`` and ``session_name`` are used as dict keys downstream
+    (``_active_session_for_name``) and typed ``str | None`` on the session
+    models. Neither is in ``SPEC_CONTAINER_ATTRS``, so the shared decoder never
+    hands them a list or dict in the first place.
+    """
     flat = flatten_otlp_attributes(resource_attrs)
     return {
         "eval_set_id": flat.get(AGENTEVALS_EVAL_SET_ID),
@@ -310,37 +316,12 @@ def _convert_otlp_log_record(log_record: dict) -> dict | None:
     return result
 
 
-def _parse_otlp_any_value(value_obj: dict):
-    """Recursively parse an OTLP AnyValue to native Python types.
-
-    Handles the full AnyValue union: stringValue, intValue, doubleValue,
-    boolValue, kvlistValue (→ dict), arrayValue (→ list), bytesValue.
-    """
-    if "stringValue" in value_obj:
-        return value_obj["stringValue"]
-    if "intValue" in value_obj:
-        return int(value_obj["intValue"])
-    if "doubleValue" in value_obj:
-        return float(value_obj["doubleValue"])
-    if "boolValue" in value_obj:
-        return value_obj["boolValue"]
-    if "kvlistValue" in value_obj:
-        kv = value_obj["kvlistValue"]
-        return {item.get("key", ""): _parse_otlp_any_value(item.get("value", {})) for item in kv.get("values", [])}
-    if "arrayValue" in value_obj:
-        arr = value_obj["arrayValue"]
-        return [_parse_otlp_any_value(v) for v in arr.get("values", [])]
-    if "bytesValue" in value_obj:
-        return value_obj["bytesValue"]
-    return value_obj
-
-
 def _parse_otlp_body(body_raw: dict) -> dict | str:
     """Parse OTLP log record body value.
 
     Top-level stringValue bodies are JSON-decoded (Strands-style logs store
     message content as JSON strings). All other AnyValue types are parsed
-    recursively via ``_parse_otlp_any_value`` (handles the nested kvlistValue /
+    recursively via ``decode_any_value`` (handles the nested kvlistValue /
     arrayValue structures used by the OpenAI instrumentor).
     """
     if "stringValue" in body_raw:
@@ -351,4 +332,4 @@ def _parse_otlp_body(body_raw: dict) -> dict | str:
             return json.loads(raw)
         except (json.JSONDecodeError, TypeError):
             return raw
-    return _parse_otlp_any_value(body_raw)
+    return decode_any_value(body_raw)

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/src/agentevals/extraction.py

@@ -17,6 +17,7 @@ import re
 from typing import Any, Protocol, TypedDict, TypeVar
 
 from .loader.base import Span, Trace
+from .otlp_anyvalue import decode_attributes
 from .trace_attrs import (
     ADK_LLM_REQUEST,
     ADK_LLM_RESPONSE,
@@ -523,20 +524,12 @@ def is_invocation_span(span: Span) -> bool:
 
 
 def flatten_otlp_attributes(attrs_list: list[dict]) -> dict[str, Any]:
-    """Convert OTLP attributes array [{key, value: {stringValue|...}}] to flat dict."""
-    result: dict[str, Any] = {}
-    for attr in attrs_list:
-        key = attr.get("key", "")
-        value_obj = attr.get("value", {})
-        if "stringValue" in value_obj:
-            result[key] = value_obj["stringValue"]
-        elif "intValue" in value_obj:
-            result[key] = int(value_obj["intValue"])
-        elif "doubleValue" in value_obj:
-            result[key] = float(value_obj["doubleValue"])
-        elif "boolValue" in value_obj:
-            result[key] = value_obj["boolValue"]
-    return result
+    """Convert OTLP attributes array [{key, value: {stringValue|...}}] to flat dict.
+
+    Delegates to the shared ``AnyValue`` decoder so array/kvlist/bytes
+    attributes survive instead of being dropped.
+    """
+    return decode_attributes(attrs_list)
 
 
 # ---------------------------------------------------------------------------

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/src/agentevals/loader/otlp.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import logging
 
+from ..otlp_anyvalue import decode_attribute, decode_attributes, is_any_value
 from ..trace_attrs import (
     OTEL_GENAI_INPUT_MESSAGES,
     OTEL_GENAI_OUTPUT_MESSAGES,
@@ -175,8 +176,10 @@ class OtlpJsonLoader(TraceLoader):
                     key = attr.get("key", "")
                     if key in self._GENAI_EVENT_KEYS and key not in attributes:
                         value_obj = attr.get("value", {})
-                        if "stringValue" in value_obj:
-                            attributes[key] = value_obj["stringValue"]
+                        if is_any_value(value_obj):
+                            keep, value = decode_attribute(key, value_obj)
+                            if keep:
+                                attributes[key] = value
 
     def _extract_attributes(self, attrs) -> dict:
         """Convert attributes to a flat ``{key: value}`` dict.
@@ -192,25 +195,7 @@ class OtlpJsonLoader(TraceLoader):
         if isinstance(attrs, dict):
             return self._flatten_nested_dict(attrs)
 
-        result = {}
-        for attr in attrs:
-            key = attr.get("key", "")
-            value_obj = attr.get("value", {})
-
-            if "stringValue" in value_obj:
-                result[key] = value_obj["stringValue"]
-            elif "intValue" in value_obj:
-                result[key] = int(value_obj["intValue"])
-            elif "doubleValue" in value_obj:
-                result[key] = float(value_obj["doubleValue"])
-            elif "boolValue" in value_obj:
-                result[key] = value_obj["boolValue"]
-            elif "arrayValue" in value_obj:
-                result[key] = json.dumps(value_obj["arrayValue"])
-            elif "kvlistValue" in value_obj:
-                result[key] = json.dumps(value_obj["kvlistValue"])
-
-        return result
+        return decode_attributes(attrs)
 
     @staticmethod
     def _flatten_nested_dict(d: dict, prefix: str = "") -> dict:

agentevals_cli-0.9.10/src/agentevals/otlp_anyvalue.py

@@ -0,0 +1,118 @@
+"""Shared decoder for the OTLP ``AnyValue`` union.
+
+OTLP encodes every attribute value, log body and nested element as an
+``AnyValue``: a one-of wrapper such as ``{"stringValue": "chat"}`` or
+``{"arrayValue": {"values": [...]}}``. The protobuf receiver (via
+``MessageToDict``) and OTLP/JSON payloads deliver that same dict shape, so
+every consumer needs identical decoding rules.
+
+This module depends only on the standard library and ``trace_attrs`` (a leaf
+constants module), so ``extraction``, ``loader.otlp`` and ``api.otlp_processing``
+can all use it without creating an import cycle.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .trace_attrs import SPEC_CONTAINER_ATTRS
+
+logger = logging.getLogger(__name__)
+
+ANY_VALUE_FIELDS = (
+    "stringValue",
+    "intValue",
+    "doubleValue",
+    "boolValue",
+    "kvlistValue",
+    "arrayValue",
+    "bytesValue",
+)
+
+
+def decode_any_value(value_obj: dict) -> Any:
+    """Recursively decode an OTLP ``AnyValue`` to a native Python value.
+
+    Handles the full union: stringValue, intValue (OTLP sends it as a
+    string), doubleValue, boolValue, kvlistValue (→ dict), arrayValue
+    (→ list), bytesValue.
+
+    ``bytesValue`` is returned unchanged. ``MessageToDict`` base64-encodes
+    protobuf bytes fields and OTLP/JSON does the same, so callers already
+    receive a str; decoding it here would change the value they see today.
+
+    A value carrying none of the union fields is returned as-is.
+    """
+    if "stringValue" in value_obj:
+        return value_obj["stringValue"]
+    if "intValue" in value_obj:
+        return int(value_obj["intValue"])
+    if "doubleValue" in value_obj:
+        return float(value_obj["doubleValue"])
+    if "boolValue" in value_obj:
+        return value_obj["boolValue"]
+    if "kvlistValue" in value_obj:
+        kv = value_obj["kvlistValue"]
+        return {item.get("key", ""): decode_any_value(item.get("value", {})) for item in kv.get("values", [])}
+    if "arrayValue" in value_obj:
+        arr = value_obj["arrayValue"]
+        return [decode_any_value(v) for v in arr.get("values", [])]
+    if "bytesValue" in value_obj:
+        return value_obj["bytesValue"]
+    return value_obj
+
+
+def is_any_value(value_obj: dict) -> bool:
+    """Return True when *value_obj* carries one of the ``AnyValue`` fields."""
+    for field in ANY_VALUE_FIELDS:
+        if field in value_obj:
+            return True
+    return False
+
+
+def decode_attribute(key: str, value_obj: dict) -> tuple[bool, Any]:
+    """Decode one attribute, applying the container allowlist.
+
+    Returns ``(keep, value)``. Scalars are always kept. A list or dict is kept
+    only when *key* is in :data:`SPEC_CONTAINER_ATTRS`; otherwise it is dropped,
+    which is what ``extraction.py`` did with containers before this decoder was
+    shared.
+
+    Dropping rather than serialising is deliberate: JSON-dumping the value would
+    put a blob back into user-visible output, which is the symptom #173 is
+    about. What the default *should* be is tracked in #208.
+    """
+    value = decode_any_value(value_obj)
+    if isinstance(value, (list, dict)) and key not in SPEC_CONTAINER_ATTRS:
+        logger.warning(
+            "Dropping container value for %s (got %s); only spec container attributes are kept",
+            key,
+            type(value).__name__,
+        )
+        return False, None
+    return True, value
+
+
+def decode_attributes(attrs_list: list[dict]) -> dict[str, Any]:
+    """Decode an OTLP attributes array to a flat ``{key: value}`` dict.
+
+    Entries whose value carries no ``AnyValue`` field are skipped, matching the
+    behaviour every call site had before they shared this decoder.
+
+    Container values survive only for the keys in
+    :data:`~agentevals.trace_attrs.SPEC_CONTAINER_ATTRS`. Keeping the allowlist
+    here rather than narrowing per consumer means an attribute nobody has
+    thought about cannot become an unhashable dict key downstream - there is
+    nothing to remember, because it was never widened in the first place.
+    """
+    result: dict[str, Any] = {}
+    for attr in attrs_list:
+        value_obj = attr.get("value", {})
+        if not is_any_value(value_obj):
+            continue
+        key = attr.get("key", "")
+        keep, value = decode_attribute(key, value_obj)
+        if keep:
+            result[key] = value
+    return result

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/src/agentevals/trace_attrs.py

@@ -84,3 +84,33 @@ GENAI_ATTRIBUTE_ALIASES: dict[str, list[str]] = {
 
 # agentevals custom attributes (repository-specific, outside OTel semconv)
 AGENTEVALS_SESSION_ID = "agentevals.session_id"
+AGENTEVALS_EVAL_SET_ID = "agentevals.eval_set_id"
+AGENTEVALS_SESSION_NAME = "agentevals.session_name"
+
+# Attributes the GenAI semconv types as arrays or structured values. These are
+# the only keys the shared AnyValue decoder returns as a native list or dict;
+# every other key is decoded to a scalar or dropped, which is what
+# ``extraction.py`` did before the decoder was shared.
+#
+# The set is an allowlist on purpose. A missing entry drops one value, matching
+# the pre-existing extraction behaviour; a denylist would instead let an
+# unhashable value reach a dict key or set member on an unauthenticated
+# receiver port, which crashes ingestion. See the discussion on #187.
+#
+# Hand-maintained: opentelemetry-semantic-conventions exposes constants and
+# prose docstrings only, so attribute value types are not machine-readable and
+# this set cannot be derived from the package.
+#
+# What should happen to container values on keys outside this set is not
+# settled; today they are dropped. Tracked in #208.
+SPEC_CONTAINER_ATTRS: frozenset[str] = frozenset(
+    {
+        OTEL_GENAI_RESPONSE_FINISH_REASONS,
+        OTEL_GENAI_INPUT_MESSAGES,
+        OTEL_GENAI_OUTPUT_MESSAGES,
+        OTEL_GENAI_TOOL_DEFINITIONS,
+        OTEL_GENAI_SYSTEM_INSTRUCTIONS,
+        OTEL_GENAI_TOOL_CALL_ARGUMENTS,
+        OTEL_GENAI_TOOL_CALL_RESULT,
+    }
+)

{agentevals_cli-0.9.9 → agentevals_cli-0.9.10}/tests/test_extraction.py

@@ -6,6 +6,7 @@ import json
 
 import pytest
 
+from agentevals import trace_attrs
 from agentevals.extraction import (
     AdkExtractor,
     GenAIExtractor,
@@ -400,6 +401,129 @@ class TestFlattenOtlpAttributes:
         )
         assert result == {"str": "hello", "num": 3.14, "flag": True}
 
+    def test_array_value(self):
+        result = flatten_otlp_attributes(
+            [
+                {
+                    "key": "gen_ai.response.finish_reasons",
+                    "value": {"arrayValue": {"values": [{"stringValue": "stop"}]}},
+                },
+            ]
+        )
+        assert result == {"gen_ai.response.finish_reasons": ["stop"]}
+
+    def test_kvlist_value(self):
+        result = flatten_otlp_attributes(
+            [
+                {
+                    "key": "gen_ai.tool.call.arguments",
+                    "value": {
+                        "kvlistValue": {
+                            "values": [
+                                {"key": "city", "value": {"stringValue": "Berlin"}},
+                                {"key": "metric", "value": {"boolValue": False}},
+                            ]
+                        }
+                    },
+                },
+            ]
+        )
+        assert result == {"gen_ai.tool.call.arguments": {"city": "Berlin", "metric": False}}
+
+    def test_array_of_kvlist(self):
+        """Messages arrive as an arrayValue of kvlistValue."""
+        result = flatten_otlp_attributes(
+            [
+                {
+                    "key": "gen_ai.input.messages",
+                    "value": {
+                        "arrayValue": {
+                            "values": [
+                                {"kvlistValue": {"values": [{"key": "role", "value": {"stringValue": "user"}}]}},
+                            ]
+                        }
+                    },
+                },
+            ]
+        )
+        assert result == {"gen_ai.input.messages": [{"role": "user"}]}
+
+    def test_finish_reasons_survive_to_extracted_model_info(self):
+        """The symptom #173 names: gen_ai.response.finish_reasons reaching the
+        consumer as ["stop"] rather than a literal blob or nothing.
+
+        Asserting through extract_extended_model_info_from_attrs rather than at
+        the decoder keeps the whole path covered - decoding it correctly is not
+        the same as it arriving correctly.
+        """
+        attrs = flatten_otlp_attributes(
+            [
+                {
+                    "key": "gen_ai.response.finish_reasons",
+                    "value": {"arrayValue": {"values": [{"stringValue": "stop"}]}},
+                },
+                {"key": "gen_ai.response.model", "value": {"stringValue": "claude-opus-5"}},
+            ]
+        )
+        info = extract_extended_model_info_from_attrs(attrs)
+        assert info["finish_reasons"] == ["stop"]
+        assert info["response_model"] == "claude-opus-5"
+
+    def test_multiple_finish_reasons_survive(self):
+        attrs = flatten_otlp_attributes(
+            [
+                {
+                    "key": "gen_ai.response.finish_reasons",
+                    "value": {"arrayValue": {"values": [{"stringValue": "stop"}, {"stringValue": "length"}]}},
+                }
+            ]
+        )
+        assert extract_extended_model_info_from_attrs(attrs)["finish_reasons"] == [
+            "stop",
+            "length",
+        ]
+
+    def test_unlisted_key_drops_container_value(self):
+        """Containers survive only for SPEC_CONTAINER_ATTRS. Everything else is
+        dropped, which is what extraction did before the decoder was shared."""
+        attrs = flatten_otlp_attributes(
+            [
+                {
+                    "key": "gen_ai.response.model",
+                    "value": {"arrayValue": {"values": [{"stringValue": "claude-opus-5"}]}},
+                },
+                {"key": "gen_ai.request.model", "value": {"stringValue": "claude-sonnet-5"}},
+            ]
+        )
+        assert "gen_ai.response.model" not in attrs
+        info = extract_extended_model_info_from_attrs(attrs)
+        assert info["response_model"] is None
+        assert info["request_model"] == "claude-sonnet-5"
+
+    def test_no_unlisted_key_can_yield_an_unhashable_value(self):
+        """The property the allowlist exists for: nothing outside
+        SPEC_CONTAINER_ATTRS can reach a consumer as a dict key or set member
+        and raise TypeError. Covers every attribute constant we declare, so a
+        new one cannot quietly reopen the hazard."""
+        container = {"arrayValue": {"values": [{"stringValue": "x"}]}}
+        for name in dir(trace_attrs):
+            if not name.isupper():
+                continue
+            key = getattr(trace_attrs, name)
+            if not isinstance(key, str):
+                continue
+            value = flatten_otlp_attributes([{"key": key, "value": container}]).get(key)
+            if key in trace_attrs.SPEC_CONTAINER_ATTRS:
+                assert value == ["x"], f"{key} should keep its container"
+            else:
+                assert value is None, f"{key} leaked a container"
+                hash(value)
+
+    def test_bytes_value(self):
+        """MessageToDict base64-encodes bytes fields, so the decoder sees a str."""
+        result = flatten_otlp_attributes([{"key": "payload", "value": {"bytesValue": "AP9oaQ=="}}])
+        assert result == {"payload": "AP9oaQ=="}
+
     def test_empty(self):
         assert flatten_otlp_attributes([]) == {}