arize-phoenix 2.0.0__py3-none-any.whl → 2.2.0rc0__py3-none-any.whl

phoenix/server/templates/index.html

@@ -4,8 +4,12 @@
     <title>Phoenix</title>
     <link rel="icon" href="{{basename}}/favicon.ico" type="image/x-icon"></link>
     <meta charset="UTF-8" />
-    <meta name="description" content="Explore, Analyze, Curate" />
+    <meta name="title" content="Arize Phoenix" />
+    <meta name="description" content="AI Observability & Evaluation" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta property="og:title" content="Arize Phoenix" />
+    <meta property="og:description" content="AI Observability & Evaluation" />
+    <meta property="og:image" content="https://raw.githubusercontent.com/Arize-ai/phoenix-assets/main/images/socal/social-preview-horizontal.jpg" />
     <meta name="theme-color" content="#ffffff" />
     <link rel="stylesheet" src="{{basename}}/index.css"></link>
     <link

phoenix/server/trace_handler.py

@@ -0,0 +1,56 @@
+import asyncio
+import gzip
+import zlib
+from typing import Protocol
+
+from google.protobuf.message import DecodeError
+from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
+    ExportTraceServiceRequest,
+)
+from opentelemetry.proto.trace.v1.trace_pb2 import Span
+from starlette.endpoints import HTTPEndpoint
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.status import HTTP_415_UNSUPPORTED_MEDIA_TYPE, HTTP_422_UNPROCESSABLE_ENTITY
+
+
+class SupportsPutSpan(Protocol):
+    def put(self, span: Span) -> None:
+        ...
+
+
+class TraceHandler(HTTPEndpoint):
+    queue: SupportsPutSpan
+
+    async def post(self, request: Request) -> Response:
+        content_type = request.headers.get("content-type")
+        if content_type != "application/x-protobuf":
+            return Response(
+                content=f"Unsupported content type: {content_type}",
+                status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            )
+        content_encoding = request.headers.get("content-encoding")
+        if content_encoding and content_encoding not in ("gzip", "deflate"):
+            return Response(
+                content=f"Unsupported content encoding: {content_encoding}",
+                status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            )
+        body = await request.body()
+        if content_encoding == "gzip":
+            body = gzip.decompress(body)
+        elif content_encoding == "deflate":
+            body = zlib.decompress(body)
+        req = ExportTraceServiceRequest()
+        try:
+            req.ParseFromString(body)
+        except DecodeError:
+            return Response(
+                content="Request body is invalid ExportTraceServiceRequest",
+                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            )
+        for resource_spans in req.resource_spans:
+            for scope_span in resource_spans.scope_spans:
+                for span in scope_span.spans:
+                    self.queue.put(span)
+                    await asyncio.sleep(0)
+        return Response()

phoenix/session/session.py

@@ -31,6 +31,7 @@ from phoenix.server.thread_server import ThreadServer
 from phoenix.services import AppService
 from phoenix.trace.dsl import SpanFilter
 from phoenix.trace.dsl.query import SpanQuery
+from phoenix.trace.otel import encode
 from phoenix.trace.span_json_encoder import span_to_json
 from phoenix.trace.trace_dataset import TraceDataset
 
@@ -117,7 +118,7 @@ class Session(ABC):
         self.traces = Traces()
         if trace_dataset:
             for span in trace_dataset.to_spans():
-                self.traces.put(span)
+                self.traces.put(encode(span))
 
         self.evals: Evals = Evals()
 

phoenix/trace/exporter.py

@@ -6,21 +6,22 @@ from threading import Thread
 from types import MethodType
 from typing import Any, Optional, Union
 
+import opentelemetry.proto.trace.v1.trace_pb2 as otlp
 import requests
 from requests import Session
 from typing_extensions import TypeAlias, assert_never
 
 import phoenix.trace.v1 as pb
 from phoenix.config import get_env_collector_endpoint, get_env_host, get_env_port
+from phoenix.trace.otel import encode
 from phoenix.trace.schemas import Span
-from phoenix.trace.v1.utils import encode
 
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
 END_OF_QUEUE = None  # sentinel value for queue termination
 
-Message: TypeAlias = Union[pb.Span, pb.Evaluation]
+Message: TypeAlias = Union[otlp.Span, pb.Evaluation]
 
 
 class NoOpExporter:
@@ -102,7 +103,7 @@ class HttpExporter:
             logger.exception(e)
 
     def _url(self, message: Message) -> str:
-        if isinstance(message, pb.Span):
+        if isinstance(message, otlp.Span):
             return f"{self._base_url}/v1/spans"
         if isinstance(message, pb.Evaluation):
             return f"{self._base_url}/v1/evaluations"

phoenix/trace/langchain/tracer.py

@@ -1,8 +1,8 @@
 import json
 import logging
 from copy import deepcopy
-from datetime import datetime
-from typing import Any, Dict, Iterable, Iterator, List, Mapping, Optional, Tuple
+from datetime import datetime, timezone
+from typing import Any, Dict, Iterable, Iterator, List, Mapping, Optional, Tuple, cast
 from uuid import UUID
 
 from langchain.callbacks.tracers.base import BaseTracer
@@ -356,13 +356,19 @@ class OpenInferenceTracer(Tracer, BaseTracer):  # type: ignore
             if "agent" in run["name"].lower()
             else _langchain_run_type_to_span_kind(run["run_type"])
         )
+        start_time = cast(datetime, run["start_time"])
+        end_time = cast(Optional[datetime], run.get("end_time"))
+        if _is_tz_naive(start_time):
+            start_time = start_time.replace(tzinfo=timezone.utc)
+        if end_time and _is_tz_naive(end_time):
+            end_time = end_time.replace(tzinfo=timezone.utc)
         span = self.create_span(
             name=run["name"],
             span_kind=span_kind,
             parent_id=None if parent is None else parent.context.span_id,
             trace_id=None if parent is None else parent.context.trace_id,
-            start_time=run["start_time"],
-            end_time=run["end_time"],
+            start_time=start_time,
+            end_time=end_time,
             status_code=status_code,
             attributes=attributes,
             events=events,
@@ -420,3 +426,7 @@ class OpenInferenceTracer(Tracer, BaseTracer):  # type: ignore
             name=name or "",
         )
         self._start_trace(run)
+
+
+def _is_tz_naive(dt: datetime) -> bool:
+    return dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None

phoenix/trace/otel.py

@@ -0,0 +1,409 @@
+from datetime import datetime, timezone
+from types import MappingProxyType
+from typing import (
+    Any,
+    DefaultDict,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
+from uuid import UUID
+
+import opentelemetry.proto.trace.v1.trace_pb2 as otlp
+from opentelemetry.proto.common.v1.common_pb2 import AnyValue, ArrayValue, KeyValue
+from opentelemetry.util.types import Attributes, AttributeValue
+from typing_extensions import TypeAlias, assert_never
+
+import phoenix.trace.semantic_conventions as sem_conv
+from phoenix.trace.schemas import (
+    MimeType,
+    Span,
+    SpanContext,
+    SpanEvent,
+    SpanException,
+    SpanID,
+    SpanKind,
+    SpanStatusCode,
+    TraceID,
+)
+from phoenix.trace.semantic_conventions import (
+    EXCEPTION_ESCAPED,
+    EXCEPTION_MESSAGE,
+    EXCEPTION_STACKTRACE,
+    EXCEPTION_TYPE,
+    INPUT_MIME_TYPE,
+    OPENINFERENCE_SPAN_KIND,
+    OUTPUT_MIME_TYPE,
+)
+
+
+def decode(otlp_span: otlp.Span) -> Span:
+    trace_id = cast(TraceID, _decode_identifier(otlp_span.trace_id))
+    span_id = cast(SpanID, _decode_identifier(otlp_span.span_id))
+    parent_id = _decode_identifier(otlp_span.parent_span_id)
+
+    start_time = _decode_unix_nano(otlp_span.start_time_unix_nano)
+    end_time = (
+        _decode_unix_nano(otlp_span.end_time_unix_nano) if otlp_span.end_time_unix_nano else None
+    )
+
+    attributes = dict(_unflatten(_decode_key_values(otlp_span.attributes)))
+    span_kind = SpanKind(attributes.pop(OPENINFERENCE_SPAN_KIND, None))
+
+    for mime_type in (INPUT_MIME_TYPE, OUTPUT_MIME_TYPE):
+        if mime_type in attributes:
+            attributes[mime_type] = MimeType(attributes[mime_type])
+
+    status_code, status_message = _decode_status(otlp_span.status)
+    events = [_decode_event(event) for event in otlp_span.events]
+
+    return Span(
+        name=otlp_span.name,
+        context=SpanContext(
+            trace_id=trace_id,
+            span_id=span_id,
+        ),
+        parent_id=parent_id,
+        start_time=start_time,
+        end_time=end_time,
+        attributes=attributes,
+        span_kind=span_kind,
+        status_code=status_code,
+        status_message=status_message,
+        events=events,
+        conversation=None,
+    )
+
+
+def _decode_identifier(identifier: bytes) -> Optional[UUID]:
+    # This is a stopgap solution until we move away from UUIDs.
+    # The goal is to convert bytes to UUID in a deterministic way.
+    if not identifier:
+        return None
+    try:
+        # OTEL trace_id is 16 bytes, so it matches UUID's length, but
+        # OTEL span_id is 8 bytes, so we double up by concatenating.
+        return UUID(bytes=identifier[:8] + identifier[-8:])
+    except ValueError:
+        # Fallback to a seeding a UUID from the bytes.
+        return UUID(int=int.from_bytes(identifier, byteorder="big"))
+
+
+def _decode_event(otlp_event: otlp.Span.Event) -> SpanEvent:
+    name = otlp_event.name
+    timestamp = _decode_unix_nano(otlp_event.time_unix_nano)
+    attributes = dict(_decode_key_values(otlp_event.attributes))
+    if name == "exception":
+        return SpanException(
+            timestamp=timestamp,
+            message=attributes.get(EXCEPTION_MESSAGE) or "",
+            exception_type=attributes.get(EXCEPTION_TYPE),
+            exception_escaped=attributes.get(EXCEPTION_ESCAPED),
+            exception_stacktrace=attributes.get(EXCEPTION_STACKTRACE),
+        )
+    return SpanEvent(
+        name=name,
+        timestamp=timestamp,
+        attributes=attributes,
+    )
+
+
+def _decode_unix_nano(time_unix_nano: int) -> datetime:
+    # floating point rounding error can cause the timestamp to be slightly different from expected
+    return datetime.fromtimestamp(time_unix_nano / 1e9, tz=timezone.utc)
+
+
+def _decode_key_values(
+    key_values: Iterable[KeyValue],
+) -> Iterator[Tuple[str, Any]]:
+    return ((kv.key, _decode_value(kv.value)) for kv in key_values)
+
+
+def _decode_value(any_value: AnyValue) -> Any:
+    which = any_value.WhichOneof("value")
+    if which == "string_value":
+        return any_value.string_value
+    if which == "bool_value":
+        return any_value.bool_value
+    if which == "int_value":
+        return any_value.int_value
+    if which == "double_value":
+        return any_value.double_value
+    if which == "array_value":
+        return [_decode_value(value) for value in any_value.array_value.values]
+    if which == "kvlist_value":
+        return dict(_decode_key_values(any_value.kvlist_value.values))
+    if which == "bytes_value":
+        return any_value.bytes_value
+    if which is None:
+        return None
+    assert_never(which)
+
+
+StatusMessage: TypeAlias = str
+
+_STATUS_DECODING = MappingProxyType(
+    {
+        otlp.Status.StatusCode.STATUS_CODE_UNSET: SpanStatusCode.UNSET,
+        otlp.Status.StatusCode.STATUS_CODE_OK: SpanStatusCode.OK,
+        otlp.Status.StatusCode.STATUS_CODE_ERROR: SpanStatusCode.ERROR,
+    }
+)
+
+
+def _decode_status(otlp_status: otlp.Status) -> Tuple[SpanStatusCode, StatusMessage]:
+    status_code = _STATUS_DECODING.get(otlp_status.code, SpanStatusCode.UNSET)
+    return status_code, otlp_status.message
+
+
+_SEMANTIC_CONVENTIONS: List[str] = sorted(
+    (getattr(sem_conv, name) for name in dir(sem_conv) if name.isupper()),
+    reverse=True,
+)  # sorted so the longer strings go first
+
+
+def _semantic_convention_prefix_partition(key: str, separator: str = ".") -> Tuple[str, str, str]:
+    """Return the longest prefix of `key` that is a semantic convention, and the remaining suffix
+    separated by `.`. For example, if `key` is "retrieval.documents.2.document.score", return
+    ("retrieval.documents", ".", "2.document.score"). The return signature is based on Python's
+    `.partition` method for strings.
+    """
+    for prefix in _SEMANTIC_CONVENTIONS:
+        if key == prefix:
+            return key, "", ""
+        if key.startswith(prefix) and key[len(prefix) :].startswith(separator):
+            return prefix, separator, key[len(prefix) + len(separator) :]
+    return "", "", ""
+
+
+class _Trie(DefaultDict[Union[str, int], "_Trie"]):
+    """Prefix Tree with special handling for indices (i.e. all-digit keys)."""
+
+    def __init__(self) -> None:
+        super().__init__(_Trie)
+        self.value: Any = None
+        self.indices: Set[int] = set()
+        self.branches: Set[Union[str, int]] = set()
+
+    def set_value(self, value: Any) -> None:
+        self.value = value
+        # value and indices must not coexist
+        self.branches.update(self.indices)
+        self.indices.clear()
+
+    def add_index(self, index: int) -> "_Trie":
+        if self.value is not None:
+            self.branches.add(index)
+        elif index not in self.branches:
+            self.indices.add(index)
+        return self[index]
+
+    def add_branch(self, branch: Union[str, int]) -> "_Trie":
+        if branch in self.indices:
+            self.indices.discard(cast(int, branch))
+        self.branches.add(branch)
+        return self[branch]
+
+
+# FIXME: Ideally we should not need something so complicated as a Trie, but it's useful here
+# for backward compatibility reasons regarding some deeply nested objects such as TOOL_PARAMETERS.
+# In the future, we should `json_dumps` them and not let things get too deeply nested.
+def _build_trie(
+    key_value_pairs: Iterable[Tuple[str, Any]],
+    separator: str = ".",
+) -> _Trie:
+    """Build a Trie (a.k.a. prefix tree) from `key_value_pairs`, by partitioning the keys by
+    separator. Each partition is a branch in the Trie. Special handling is done for partitions
+    that are all digits, e.g. "0", "12", etc., which are converted to integers and collected
+    as indices.
+    """
+    trie = _Trie()
+    for key, value in key_value_pairs:
+        if value is None:
+            continue
+        t = trie
+        while True:
+            prefix, _, suffix = _semantic_convention_prefix_partition(key, separator)
+            if prefix:
+                t = t.add_branch(prefix)
+            else:
+                prefix, _, suffix = key.partition(separator)
+                if prefix.isdigit():
+                    index = int(prefix)
+                    t = t.add_index(index) if suffix else t.add_branch(index)
+                else:
+                    t = t.add_branch(prefix)
+            if not suffix:
+                break
+            key = suffix
+        t.set_value(value)
+    return trie
+
+
+def _walk(trie: _Trie, prefix: str = "") -> Iterator[Tuple[str, Any]]:
+    if trie.value is not None:
+        yield prefix, trie.value
+    elif prefix and trie.indices:
+        yield prefix, [dict(_walk(trie[index])) for index in sorted(trie.indices)]
+    elif trie.indices:
+        for index in trie.indices:
+            yield from _walk(trie[index], prefix=f"{index}")
+    elif prefix:
+        yield prefix, dict(_walk(trie))
+        return
+    for branch in trie.branches:
+        new_prefix = f"{prefix}.{branch}" if prefix else f"{branch}"
+        yield from _walk(trie[branch], new_prefix)
+
+
+def _unflatten(
+    key_value_pairs: Iterable[Tuple[str, Any]],
+    separator: str = ".",
+) -> Iterator[Tuple[str, Any]]:
+    trie = _build_trie(key_value_pairs, separator)
+    yield from _walk(trie)
+
+
+_BILLION = 1_000_000_000  # for converting seconds to nanoseconds
+
+
+def encode(span: Span) -> otlp.Span:
+    trace_id: bytes = span.context.trace_id.bytes
+    span_id: bytes = _span_id_to_bytes(span.context.span_id)
+    parent_span_id: bytes = _span_id_to_bytes(span.parent_id) if span.parent_id else bytes()
+
+    # floating point rounding error can cause the timestamp to be slightly different from expected
+    start_time_unix_nano: int = int(span.start_time.timestamp() * _BILLION)
+    end_time_unix_nano: int = int(span.end_time.timestamp() * _BILLION) if span.end_time else 0
+
+    attributes: Dict[str, Any] = span.attributes.copy()
+
+    for mime_type in (INPUT_MIME_TYPE, OUTPUT_MIME_TYPE):
+        if mime_type in attributes:
+            attributes[mime_type] = attributes[mime_type].value
+
+    for key, value in span.attributes.items():
+        if value is None:
+            # None can't be transmitted by OTLP
+            attributes.pop(key, None)
+        elif isinstance(value, Mapping):
+            attributes.pop(key, None)
+            attributes.update(_flatten_mapping(value, key))
+        elif not isinstance(value, str) and isinstance(value, Sequence) and _has_mapping(value):
+            attributes.pop(key, None)
+            attributes.update(_flatten_sequence(value, key))
+
+    attributes[OPENINFERENCE_SPAN_KIND] = span.span_kind.value
+
+    status = _encode_status(span.status_code, span.status_message)
+    events = map(_encode_event, span.events)
+
+    return otlp.Span(
+        name=span.name,
+        trace_id=trace_id,
+        span_id=span_id,
+        parent_span_id=parent_span_id,
+        start_time_unix_nano=start_time_unix_nano,
+        end_time_unix_nano=end_time_unix_nano,
+        attributes=_encode_attributes(cast(Attributes, attributes)),
+        events=events,
+        status=status,
+    )
+
+
+_STATUS_ENCODING = MappingProxyType(
+    {
+        SpanStatusCode.UNSET: otlp.Status.StatusCode.STATUS_CODE_UNSET,
+        SpanStatusCode.OK: otlp.Status.StatusCode.STATUS_CODE_OK,
+        SpanStatusCode.ERROR: otlp.Status.StatusCode.STATUS_CODE_ERROR,
+    }
+)
+
+
+def _encode_status(span_status_code: SpanStatusCode, status_message: str) -> otlp.Status:
+    code = _STATUS_ENCODING.get(span_status_code, otlp.Status.StatusCode.STATUS_CODE_UNSET)
+    return otlp.Status(code=code, message=status_message)
+
+
+def _span_id_to_bytes(span_id: SpanID) -> bytes:
+    # Note that this is not compliant with the OTEL spec, which uses 8-byte span IDs.
+    # This is a stopgap solution for backward compatibility until we move away from UUIDs.
+    return span_id.bytes
+
+
+def _has_mapping(sequence: Sequence[Any]) -> bool:
+    for item in sequence:
+        if isinstance(item, Mapping):
+            return True
+    return False
+
+
+def _flatten_mapping(
+    mapping: Mapping[str, Any],
+    prefix: str,
+) -> Iterator[Tuple[str, Any]]:
+    for key, value in mapping.items():
+        prefixed_key = f"{prefix}.{key}"
+        if isinstance(value, Mapping):
+            yield from _flatten_mapping(value, prefixed_key)
+        elif isinstance(value, Sequence):
+            yield from _flatten_sequence(value, prefixed_key)
+        elif value is not None:
+            yield prefixed_key, value
+
+
+def _flatten_sequence(
+    sequence: Sequence[Any],
+    prefix: str,
+) -> Iterator[Tuple[str, Any]]:
+    if isinstance(sequence, str) or not _has_mapping(sequence):
+        yield prefix, sequence
+    for idx, obj in enumerate(sequence):
+        if not isinstance(obj, Mapping):
+            continue
+        yield from _flatten_mapping(obj, f"{prefix}.{idx}")
+
+
+def _encode_event(event: SpanEvent) -> otlp.Span.Event:
+    return otlp.Span.Event(
+        name=event.name,
+        time_unix_nano=int(event.timestamp.timestamp() * _BILLION),
+        attributes=_encode_attributes(cast(Attributes, event.attributes)),
+    )
+
+
+def _encode_attributes(attributes: Attributes) -> Iterator[KeyValue]:
+    if not attributes:
+        return
+    for key, value in attributes.items():
+        yield KeyValue(key=key, value=_encode_value(value))
+
+
+def _encode_value(value: AttributeValue) -> AnyValue:
+    if isinstance(value, str):
+        return AnyValue(string_value=value)
+    if isinstance(value, bool):
+        return AnyValue(bool_value=value)
+    if isinstance(value, int):
+        return AnyValue(int_value=value)
+    if isinstance(value, float):
+        return AnyValue(double_value=value)
+    if isinstance(value, bytes):
+        return AnyValue(bytes_value=value)
+    if isinstance(value, Sequence):
+        return AnyValue(array_value=ArrayValue(values=map(_encode_value, value)))
+    raise ValueError(f"Unexpected attribute value {value} with type {type(value)}.")
+
+
+__all__ = [
+    "encode",
+    "decode",
+]

phoenix/trace/semantic_conventions.py

@@ -168,3 +168,5 @@ RERANKER_TOP_K = "reranker.top_k"
 """
 Top K parameter of the reranker
 """
+
+OPENINFERENCE_SPAN_KIND = "openinference.span.kind"

phoenix/trace/v1/__init__.py

@@ -1,9 +1,5 @@
 from phoenix.trace.v1.evaluation_pb2 import Evaluation
-from phoenix.trace.v1.trace_pb2 import Embedding, Retrieval, Span
 
 __all__ = [
-    "Span",
-    "Retrieval",
-    "Embedding",
     "Evaluation",
 ]

phoenix/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.0rc0"

phoenix/trace/v1/trace_pb2.py

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: trace/v1/trace.proto
-"""Generated protocol buffer code."""
-from google.protobuf.internal import builder as _builder
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import symbol_database as _symbol_database
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
-from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
-from google.protobuf import wrappers_pb2 as google_dot_protobuf_dot_wrappers__pb2
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x14trace/v1/trace.proto\x12\x16phoenix.proto.trace.v1\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1egoogle/protobuf/wrappers.proto\"\xc5\x0b\n\x04Span\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12\x35\n\x07\x63ontext\x18\x02 \x01(\x0b\x32$.phoenix.proto.trace.v1.Span.Context\x12\x34\n\x0eparent_span_id\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12\x0c\n\x04name\x18\x04 \x01(\t\x12.\n\nstart_time\x18\x05 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12,\n\x08\x65nd_time\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x33\n\x06status\x18\x07 \x01(\x0b\x32#.phoenix.proto.trace.v1.Span.Status\x12\x32\n\x06\x65vents\x18\x08 \x03(\x0b\x32\".phoenix.proto.trace.v1.Span.Event\x12:\n\nexceptions\x18\t \x03(\x0b\x32&.phoenix.proto.trace.v1.Span.Exception\x12\x33\n\x05input\x18\n \x01(\x0b\x32$.phoenix.proto.trace.v1.Span.IOValue\x12\x34\n\x06output\x18\x0b \x01(\x0b\x32$.phoenix.proto.trace.v1.Span.IOValue\x12\x0c\n\x04kind\x18\x0c \x01(\t\x12\x34\n\tretrieval\x18\r \x01(\x0b\x32!.phoenix.proto.trace.v1.Retrieval\x12\x34\n\tembedding\x18\x0e \x01(\x0b\x32!.phoenix.proto.trace.v1.Embedding\x12(\n\x03llm\x18\x0f \x01(\x0b\x32\x1b.phoenix.proto.trace.v1.LLM\x12*\n\x04tool\x18\x10 \x01(\x0b\x32\x1c.phoenix.proto.trace.v1.Tool\x1a,\n\x07\x43ontext\x12\x10\n\x08trace_id\x18\x01 \x01(\t\x12\x0f\n\x07span_id\x18\x02 \x01(\t\x1a\x95\x01\n\x06Status\x12\x36\n\x04\x63ode\x18\x01 \x01(\x0e\x32(.phoenix.proto.trace.v1.Span.Status.Code\x12-\n\x07message\x18\x02 \x01(\x0b\x32\x1c.google.protobuf.StringValue\"$\n\x04\x43ode\x12\t\n\x05UNSET\x10\x00\x12\x06\n\x02OK\x10\x01\x12\t\n\x05\x45RROR\x10\x02\x1aq\n\x05\x45vent\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12\x0c\n\x04name\x18\x02 \x01(\t\x12-\n\ttimestamp\x18\x03 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x1a\xa1\x02\n\tException\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12-\n\x07message\x18\x02 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12*\n\x04type\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12+\n\x07\x65scaped\x18\x04 \x01(\x0b\x32\x1a.google.protobuf.BoolValue\x12\x30\n\nstacktrace\x18\x05 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12-\n\ttimestamp\x18\x06 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x1az\n\x07IOValue\x12\r\n\x05value\x18\x01 \x01(\t\x12@\n\tmime_type\x18\x02 \x01(\x0e\x32-.phoenix.proto.trace.v1.Span.IOValue.MimeType\"\x1e\n\x08MimeType\x12\x08\n\x04TEXT\x10\x00\x12\x08\n\x04JSON\x10\x01\"\xdf\x02\n\tRetrieval\x12=\n\tdocuments\x18\x01 \x03(\x0b\x32*.phoenix.proto.trace.v1.Retrieval.Document\x1a\x92\x02\n\x08\x44ocument\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12(\n\x02id\x18\x02 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12*\n\x05score\x18\x03 \x01(\x0b\x32\x1b.google.protobuf.FloatValue\x12-\n\x07\x63ontent\x18\x04 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x12)\n\x08metadata\x18\x05 \x01(\x0b\x32\x17.google.protobuf.Struct\x12)\n\x04hash\x18\x06 \x01(\x0b\x32\x1b.google.protobuf.BytesValue\"\xf4\x01\n\tEmbedding\x12?\n\nembeddings\x18\x01 \x03(\x0b\x32+.phoenix.proto.trace.v1.Embedding.Embedding\x12\x30\n\nmodel_name\x18\x02 \x01(\x0b\x32\x1c.google.protobuf.StringValue\x1at\n\tEmbedding\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\x12\x0e\n\x06vector\x18\x02 \x03(\x02\x12*\n\x04text\x18\x03 \x01(\x0b\x32\x1c.google.protobuf.StringValue\"2\n\x03LLM\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Struct\"3\n\x04Tool\x12+\n\nattributes\x18\x01 \x01(\x0b\x32\x17.google.protobuf.Structb\x06proto3')
-
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'trace.v1.trace_pb2', globals())
-if _descriptor._USE_C_DESCRIPTORS == False:
-
-  DESCRIPTOR._options = None
-  _SPAN._serialized_start=144
-  _SPAN._serialized_end=1621
-  _SPAN_CONTEXT._serialized_start=894
-  _SPAN_CONTEXT._serialized_end=938
-  _SPAN_STATUS._serialized_start=941
-  _SPAN_STATUS._serialized_end=1090
-  _SPAN_STATUS_CODE._serialized_start=1054
-  _SPAN_STATUS_CODE._serialized_end=1090
-  _SPAN_EVENT._serialized_start=1092
-  _SPAN_EVENT._serialized_end=1205
-  _SPAN_EXCEPTION._serialized_start=1208
-  _SPAN_EXCEPTION._serialized_end=1497
-  _SPAN_IOVALUE._serialized_start=1499
-  _SPAN_IOVALUE._serialized_end=1621
-  _SPAN_IOVALUE_MIMETYPE._serialized_start=1591
-  _SPAN_IOVALUE_MIMETYPE._serialized_end=1621
-  _RETRIEVAL._serialized_start=1624
-  _RETRIEVAL._serialized_end=1975
-  _RETRIEVAL_DOCUMENT._serialized_start=1701
-  _RETRIEVAL_DOCUMENT._serialized_end=1975
-  _EMBEDDING._serialized_start=1978
-  _EMBEDDING._serialized_end=2222
-  _EMBEDDING_EMBEDDING._serialized_start=2106
-  _EMBEDDING_EMBEDDING._serialized_end=2222
-  _LLM._serialized_start=2224
-  _LLM._serialized_end=2274
-  _TOOL._serialized_start=2276
-  _TOOL._serialized_end=2327
-# @@protoc_insertion_point(module_scope)