arize-phoenix 11.10.0__tar.gz → 11.11.0__tar.gz

{arize_phoenix-11.10.0 → arize_phoenix-11.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.10.0
+Version: 11.11.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-11.10.0 → arize_phoenix-11.11.0}/src/phoenix/server/api/helpers/playground_clients.py

@@ -20,7 +20,7 @@ from openinference.semconv.trace import (
 )
 from strawberry import UNSET
 from strawberry.scalars import JSON as JSONScalarType
-from typing_extensions import TypeAlias, assert_never
+from typing_extensions import TypeAlias, assert_never, override
 
 from phoenix.config import getenv
 from phoenix.evals.models.rate_limiters import (
@@ -437,9 +437,9 @@ class OpenAIBaseStreamingClient(PlaygroundStreamingClient):
         if role is ChatCompletionMessageRole.TOOL:
             if tool_call_id is None:
                 raise ValueError("tool_call_id is required for tool messages")
-        return ChatCompletionToolMessageParam(
-            {"content": content, "role": "tool", "tool_call_id": tool_call_id}
-        )
+            return ChatCompletionToolMessageParam(
+                {"content": content, "role": "tool", "tool_call_id": tool_call_id}
+            )
         assert_never(role)
 
     def to_openai_tool_call_param(
@@ -1140,27 +1140,28 @@ class OpenAIStreamingClient(OpenAIBaseStreamingClient):
         self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.OPENAI.value
 
 
-@register_llm_client(
-    provider_key=GenerativeProviderKey.OPENAI,
-    model_names=[
-        "o1",
-        "o1-pro",
-        "o1-2024-12-17",
-        "o1-pro-2025-03-19",
-        "o1-mini",
-        "o1-mini-2024-09-12",
-        "o1-preview",
-        "o1-preview-2024-09-12",
-        "o3",
-        "o3-pro",
-        "o3-2025-04-16",
-        "o3-mini",
-        "o3-mini-2025-01-31",
-        "o4-mini",
-        "o4-mini-2025-04-16",
-    ],
-)
-class OpenAIReasoningStreamingClient(OpenAIStreamingClient):
+_OPENAI_REASONING_MODELS = [
+    "o1",
+    "o1-pro",
+    "o1-2024-12-17",
+    "o1-pro-2025-03-19",
+    "o1-mini",
+    "o1-mini-2024-09-12",
+    "o1-preview",
+    "o1-preview-2024-09-12",
+    "o3",
+    "o3-pro",
+    "o3-2025-04-16",
+    "o3-mini",
+    "o3-mini-2025-01-31",
+    "o4-mini",
+    "o4-mini-2025-04-16",
+]
+
+
+class OpenAIReasoningReasoningModelsMixin:
+    """Mixin class for OpenAI-style reasoning model clients (o1, o3 series)."""
+
     @classmethod
     def supported_invocation_parameters(cls) -> list[InvocationParameter]:
         return [
@@ -1191,6 +1192,16 @@ class OpenAIReasoningStreamingClient(OpenAIStreamingClient):
             ),
         ]
 
+
+@register_llm_client(
+    provider_key=GenerativeProviderKey.OPENAI,
+    model_names=_OPENAI_REASONING_MODELS,
+)
+class OpenAIReasoningNonStreamingClient(
+    OpenAIReasoningReasoningModelsMixin,
+    OpenAIStreamingClient,
+):
+    @override
     async def chat_completion_create(
         self,
         messages: list[
@@ -1283,46 +1294,11 @@ class OpenAIReasoningStreamingClient(OpenAIStreamingClient):
         if role is ChatCompletionMessageRole.TOOL:
             if tool_call_id is None:
                 raise ValueError("tool_call_id is required for tool messages")
-        return ChatCompletionToolMessageParam(
-            {"content": content, "role": "tool", "tool_call_id": tool_call_id}
-        )
+            return ChatCompletionToolMessageParam(
+                {"content": content, "role": "tool", "tool_call_id": tool_call_id}
+            )
         assert_never(role)
 
-    @staticmethod
-    def _llm_token_counts(usage: "CompletionUsage") -> Iterator[tuple[str, Any]]:
-        yield LLM_TOKEN_COUNT_PROMPT, usage.prompt_tokens
-        yield LLM_TOKEN_COUNT_COMPLETION, usage.completion_tokens
-        yield LLM_TOKEN_COUNT_TOTAL, usage.total_tokens
-
-        if hasattr(usage, "prompt_tokens_details") and usage.prompt_tokens_details is not None:
-            prompt_details = usage.prompt_tokens_details
-            if (
-                hasattr(prompt_details, "cached_tokens")
-                and prompt_details.cached_tokens is not None
-            ):
-                yield LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_READ, prompt_details.cached_tokens
-            if hasattr(prompt_details, "audio_tokens") and prompt_details.audio_tokens is not None:
-                yield LLM_TOKEN_COUNT_PROMPT_DETAILS_AUDIO, prompt_details.audio_tokens
-
-        if (
-            hasattr(usage, "completion_tokens_details")
-            and usage.completion_tokens_details is not None
-        ):
-            completion_details = usage.completion_tokens_details
-            if (
-                hasattr(completion_details, "reasoning_tokens")
-                and completion_details.reasoning_tokens is not None
-            ):
-                yield (
-                    LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING,
-                    completion_details.reasoning_tokens,
-                )
-            if (
-                hasattr(completion_details, "audio_tokens")
-                and completion_details.audio_tokens is not None
-            ):
-                yield LLM_TOKEN_COUNT_COMPLETION_DETAILS_AUDIO, completion_details.audio_tokens
-
 
 @register_llm_client(
     provider_key=GenerativeProviderKey.AZURE_OPENAI,
@@ -1376,6 +1352,113 @@ class AzureOpenAIStreamingClient(OpenAIBaseStreamingClient):
         self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.OPENAI.value
 
 
+@register_llm_client(
+    provider_key=GenerativeProviderKey.AZURE_OPENAI,
+    model_names=_OPENAI_REASONING_MODELS,
+)
+class AzureOpenAIReasoningNonStreamingClient(
+    OpenAIReasoningReasoningModelsMixin,
+    AzureOpenAIStreamingClient,
+):
+    @override
+    async def chat_completion_create(
+        self,
+        messages: list[
+            tuple[ChatCompletionMessageRole, str, Optional[str], Optional[list[JSONScalarType]]]
+        ],
+        tools: list[JSONScalarType],
+        **invocation_parameters: Any,
+    ) -> AsyncIterator[ChatCompletionChunk]:
+        from openai import NOT_GIVEN
+
+        # Convert standard messages to OpenAI messages
+        openai_messages = []
+        for message in messages:
+            openai_message = self.to_openai_chat_completion_param(*message)
+            if openai_message is not None:
+                openai_messages.append(openai_message)
+
+        throttled_create = self.rate_limiter._alimit(self.client.chat.completions.create)
+        response = await throttled_create(
+            messages=openai_messages,
+            model=self.model_name,
+            stream=False,
+            tools=tools or NOT_GIVEN,
+            **invocation_parameters,
+        )
+
+        if response.usage is not None:
+            self._attributes.update(dict(self._llm_token_counts(response.usage)))
+
+        choice = response.choices[0]
+        if choice.message.content:
+            yield TextChunk(content=choice.message.content)
+
+        if choice.message.tool_calls:
+            for tool_call in choice.message.tool_calls:
+                yield ToolCallChunk(
+                    id=tool_call.id,
+                    function=FunctionCallChunk(
+                        name=tool_call.function.name,
+                        arguments=tool_call.function.arguments,
+                    ),
+                )
+
+    def to_openai_chat_completion_param(
+        self,
+        role: ChatCompletionMessageRole,
+        content: JSONScalarType,
+        tool_call_id: Optional[str] = None,
+        tool_calls: Optional[list[JSONScalarType]] = None,
+    ) -> Optional["ChatCompletionMessageParam"]:
+        from openai.types.chat import (
+            ChatCompletionAssistantMessageParam,
+            ChatCompletionDeveloperMessageParam,
+            ChatCompletionToolMessageParam,
+            ChatCompletionUserMessageParam,
+        )
+
+        if role is ChatCompletionMessageRole.USER:
+            return ChatCompletionUserMessageParam(
+                {
+                    "content": content,
+                    "role": "user",
+                }
+            )
+        if role is ChatCompletionMessageRole.SYSTEM:
+            return ChatCompletionDeveloperMessageParam(
+                {
+                    "content": content,
+                    "role": "developer",
+                }
+            )
+        if role is ChatCompletionMessageRole.AI:
+            if tool_calls is None:
+                return ChatCompletionAssistantMessageParam(
+                    {
+                        "content": content,
+                        "role": "assistant",
+                    }
+                )
+            else:
+                return ChatCompletionAssistantMessageParam(
+                    {
+                        "content": content,
+                        "role": "assistant",
+                        "tool_calls": [
+                            self.to_openai_tool_call_param(tool_call) for tool_call in tool_calls
+                        ],
+                    }
+                )
+        if role is ChatCompletionMessageRole.TOOL:
+            if tool_call_id is None:
+                raise ValueError("tool_call_id is required for tool messages")
+            return ChatCompletionToolMessageParam(
+                {"content": content, "role": "tool", "tool_call_id": tool_call_id}
+            )
+        assert_never(role)
+
+
 @register_llm_client(
     provider_key=GenerativeProviderKey.ANTHROPIC,
     model_names=[

{arize_phoenix-11.10.0 → arize_phoenix-11.11.0}/src/phoenix/server/api/helpers/playground_registry.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, Union
 
 from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 
@@ -59,7 +59,7 @@ PLAYGROUND_CLIENT_REGISTRY: PlaygroundClientRegistry = PlaygroundClientRegistry(
 
 def register_llm_client(
     provider_key: GenerativeProviderKey,
-    model_names: list[ModelName],
+    model_names: Sequence[ModelName],
 ) -> Callable[[type["PlaygroundStreamingClient"]], type["PlaygroundStreamingClient"]]:
     def decorator(cls: type["PlaygroundStreamingClient"]) -> type["PlaygroundStreamingClient"]:
         provider_registry = PLAYGROUND_CLIENT_REGISTRY._registry.setdefault(provider_key, {})

arize_phoenix-11.11.0/src/phoenix/server/api/input_types/PromptFilter.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+import strawberry
+
+
+@strawberry.enum
+class PromptFilterColumn(Enum):
+    name = "name"
+
+
+@strawberry.input(description="The filter key and value for prompt connections")
+class PromptFilter:
+    col: PromptFilterColumn
+    value: str

{arize_phoenix-11.10.0 → arize_phoenix-11.11.0}/src/phoenix/server/api/queries.py

@@ -1,12 +1,13 @@
 import re
 from collections import defaultdict
 from datetime import datetime
-from typing import Iterable, Iterator, Optional, Union, cast
+from typing import Iterable, Iterator, Optional, Union
+from typing import cast as type_cast
 
 import numpy as np
 import numpy.typing as npt
 import strawberry
-from sqlalchemy import and_, distinct, func, select, text
+from sqlalchemy import String, and_, cast, distinct, func, select, text
 from sqlalchemy.orm import joinedload
 from starlette.authentication import UnauthenticatedUser
 from strawberry import ID, UNSET
@@ -41,6 +42,7 @@ from phoenix.server.api.input_types.DatasetSort import DatasetSort
 from phoenix.server.api.input_types.InvocationParameters import InvocationParameter
 from phoenix.server.api.input_types.ProjectFilter import ProjectFilter
 from phoenix.server.api.input_types.ProjectSort import ProjectColumn, ProjectSort
+from phoenix.server.api.input_types.PromptFilter import PromptFilter
 from phoenix.server.api.types.AnnotationConfig import AnnotationConfig, to_gql_annotation_config
 from phoenix.server.api.types.Cluster import Cluster, to_gql_clusters
 from phoenix.server.api.types.Dataset import Dataset, to_gql_dataset
@@ -728,6 +730,7 @@ class Query:
         last: Optional[int] = UNSET,
         after: Optional[CursorString] = UNSET,
         before: Optional[CursorString] = UNSET,
+        filter: Optional[PromptFilter] = UNSET,
     ) -> Connection[Prompt]:
         args = ConnectionArgs(
             first=first,
@@ -736,6 +739,14 @@ class Query:
             before=before if isinstance(before, CursorString) else None,
         )
         stmt = select(models.Prompt)
+        if filter:
+            column = getattr(models.Prompt, filter.col.value)
+            # Cast Identifier columns to String for ilike operations
+            if filter.col.value == "name":
+                column = cast(column, String)
+            stmt = stmt.where(column.ilike(f"%{filter.value}%")).order_by(
+                models.Prompt.updated_at.desc()
+            )
         async with info.context.db() as session:
             orm_prompts = await session.stream_scalars(stmt)
             data = [to_gql_prompt_from_orm(orm_prompt) async for orm_prompt in orm_prompts]
@@ -994,7 +1005,7 @@ class Query:
             """).bindparams(nspname=nspname)
             try:
                 async with info.context.db() as session:
-                    stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))
+                    stats = type_cast(Iterable[tuple[str, int]], await session.execute(stmt))
             except Exception:
                 # TODO: temporary workaround until we can reproduce the error
                 return []

{arize_phoenix-11.10.0 → arize_phoenix-11.11.0}/src/phoenix/server/api/types/GenerativeModel.py

@@ -6,14 +6,19 @@ import strawberry
 from openinference.semconv.trace import OpenInferenceLLMProviderValues
 from sqlalchemy import inspect
 from strawberry.relay import Node, NodeID
+from strawberry.relay.types import GlobalID
 from strawberry.types import Info
-from typing_extensions import assert_never
+from strawberry.types.unset import UNSET
+from typing_extensions import TypeAlias, assert_never
 
 from phoenix.db import models
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import BadRequest
+from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.types.CostBreakdown import CostBreakdown
 from phoenix.server.api.types.GenerativeProvider import GenerativeProviderKey
 from phoenix.server.api.types.ModelInterface import ModelInterface
+from phoenix.server.api.types.node import from_global_id
 from phoenix.server.api.types.SpanCostDetailSummaryEntry import SpanCostDetailSummaryEntry
 from phoenix.server.api.types.SpanCostSummary import SpanCostSummary
 from phoenix.server.api.types.TokenPrice import TokenKind, TokenPrice
@@ -25,6 +30,11 @@ class GenerativeModelKind(Enum):
     BUILT_IN = "BUILT_IN"
 
 
+ProjectId: TypeAlias = int
+TimeRangeKey: TypeAlias = tuple[Optional[datetime], Optional[datetime]]
+CachedCostSummaryKey: TypeAlias = tuple[Optional[ProjectId], TimeRangeKey]
+
+
 @strawberry.type
 class GenerativeModel(Node, ModelInterface):
     id_attr: NodeID[int]
@@ -37,6 +47,18 @@ class GenerativeModel(Node, ModelInterface):
     provider_key: Optional[GenerativeProviderKey]
     costs: strawberry.Private[Optional[list[models.TokenPrice]]] = None
     start_time: Optional[datetime] = None
+    cached_cost_summary: strawberry.Private[
+        Optional[dict[CachedCostSummaryKey, SpanCostSummary]]
+    ] = None
+
+    def add_cached_cost_summary(
+        self, project_id: Optional[int], time_range: TimeRange, cost_summary: SpanCostSummary
+    ) -> None:
+        if self.cached_cost_summary is None:
+            self.cached_cost_summary = {}
+        time_range_key = (time_range.start, time_range.end) if time_range else (None, None)
+        cache_key = (project_id, time_range_key)
+        self.cached_cost_summary[cache_key] = cost_summary
 
     @strawberry.field
     async def token_prices(self) -> list[TokenPrice]:
@@ -55,7 +77,28 @@ class GenerativeModel(Node, ModelInterface):
         return token_prices
 
     @strawberry.field
-    async def cost_summary(self, info: Info[Context, None]) -> SpanCostSummary:
+    async def cost_summary(
+        self,
+        info: Info[Context, None],
+        project_id: Optional[GlobalID] = UNSET,
+        time_range: Optional[TimeRange] = UNSET,
+    ) -> SpanCostSummary:
+        if self.cached_cost_summary is not None:
+            time_range_key = (time_range.start, time_range.end) if time_range else (None, None)
+            project_rowid: Optional[int] = None
+            if project_id:
+                type_name, project_rowid = from_global_id(project_id)
+                if type_name != models.Project.__name__:
+                    raise BadRequest("Invalid Project ID")
+            cache_key = (project_rowid, time_range_key)
+            if cache_key in self.cached_cost_summary:
+                return self.cached_cost_summary[cache_key]
+
+        if time_range or project_id:
+            raise BadRequest(
+                "Cost summaries for specific projects or time ranges are not yet implemented"
+            )
+
         loader = info.context.data_loaders.span_cost_summary_by_generative_model
         summary = await loader.load(self.id_attr)
         return SpanCostSummary(
@@ -98,7 +141,9 @@ class GenerativeModel(Node, ModelInterface):
         return await info.context.data_loaders.last_used_times_by_generative_model_id.load(model_id)
 
 
-def to_gql_generative_model(model: models.GenerativeModel) -> GenerativeModel:
+def to_gql_generative_model(
+    model: models.GenerativeModel,
+) -> GenerativeModel:
     costs_are_loaded = isinstance(inspect(model).attrs.token_prices.loaded_value, list)
     name_pattern = model.name_pattern.pattern
     assert isinstance(name_pattern, str)

{arize_phoenix-11.10.0 → arize_phoenix-11.11.0}/src/phoenix/server/api/types/Project.py

@@ -33,6 +33,7 @@ from phoenix.server.api.types.AnnotationConfig import AnnotationConfig, to_gql_a
 from phoenix.server.api.types.AnnotationSummary import AnnotationSummary
 from phoenix.server.api.types.CostBreakdown import CostBreakdown
 from phoenix.server.api.types.DocumentEvaluationSummary import DocumentEvaluationSummary
+from phoenix.server.api.types.GenerativeModel import GenerativeModel, to_gql_generative_model
 from phoenix.server.api.types.pagination import (
     ConnectionArgs,
     Cursor,
@@ -1326,6 +1327,130 @@ class Project(Node):
             names=sorted(list(unique_names)),
         )
 
+    @strawberry.field
+    async def top_models_by_cost(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+    ) -> list[GenerativeModel]:
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        async with info.context.db() as session:
+            stmt = (
+                select(
+                    models.GenerativeModel,
+                    func.sum(models.SpanCost.total_tokens).label("total_tokens"),
+                    func.sum(models.SpanCost.prompt_tokens).label("prompt_tokens"),
+                    func.sum(models.SpanCost.completion_tokens).label("completion_tokens"),
+                    func.sum(models.SpanCost.total_cost).label("total_cost"),
+                    func.sum(models.SpanCost.prompt_cost).label("prompt_cost"),
+                    func.sum(models.SpanCost.completion_cost).label("completion_cost"),
+                )
+                .join(
+                    models.SpanCost,
+                    models.SpanCost.model_id == models.GenerativeModel.id,
+                )
+                .join(
+                    models.Trace,
+                    models.SpanCost.trace_rowid == models.Trace.id,
+                )
+                .where(models.Trace.project_rowid == self.project_rowid)
+                .where(models.SpanCost.model_id.isnot(None))
+                .where(models.SpanCost.span_start_time >= time_range.start)
+                .group_by(models.SpanCost.model_id)
+                .order_by(func.sum(models.SpanCost.total_cost).desc())
+            )
+            if time_range.end:
+                stmt = stmt.where(models.SpanCost.span_start_time < time_range.end)
+            results: list[GenerativeModel] = []
+            async for (
+                model,
+                total_tokens,
+                prompt_tokens,
+                completion_tokens,
+                total_cost,
+                prompt_cost,
+                completion_cost,
+            ) in await session.stream(stmt):
+                cost_summary = SpanCostSummary(
+                    prompt=CostBreakdown(tokens=prompt_tokens, cost=prompt_cost),
+                    completion=CostBreakdown(tokens=completion_tokens, cost=completion_cost),
+                    total=CostBreakdown(tokens=total_tokens, cost=total_cost),
+                )
+                cache_time_range = TimeRange(
+                    start=time_range.start,
+                    end=time_range.end,
+                )
+                gql_model = to_gql_generative_model(model)
+                gql_model.add_cached_cost_summary(
+                    self.project_rowid, cache_time_range, cost_summary
+                )
+                results.append(gql_model)
+            return results
+
+    @strawberry.field
+    async def top_models_by_token_count(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+    ) -> list[GenerativeModel]:
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        async with info.context.db() as session:
+            stmt = (
+                select(
+                    models.GenerativeModel,
+                    func.sum(models.SpanCost.total_tokens).label("total_tokens"),
+                    func.sum(models.SpanCost.prompt_tokens).label("prompt_tokens"),
+                    func.sum(models.SpanCost.completion_tokens).label("completion_tokens"),
+                    func.sum(models.SpanCost.total_cost).label("total_cost"),
+                    func.sum(models.SpanCost.prompt_cost).label("prompt_cost"),
+                    func.sum(models.SpanCost.completion_cost).label("completion_cost"),
+                )
+                .join(
+                    models.SpanCost,
+                    models.SpanCost.model_id == models.GenerativeModel.id,
+                )
+                .join(
+                    models.Trace,
+                    models.SpanCost.trace_rowid == models.Trace.id,
+                )
+                .where(models.Trace.project_rowid == self.project_rowid)
+                .where(models.SpanCost.model_id.isnot(None))
+                .where(models.SpanCost.span_start_time >= time_range.start)
+                .group_by(models.SpanCost.model_id)
+                .order_by(func.sum(models.SpanCost.total_tokens).desc())
+            )
+            if time_range.end:
+                stmt = stmt.where(models.SpanCost.span_start_time < time_range.end)
+            results: list[GenerativeModel] = []
+            async for (
+                model,
+                total_tokens,
+                prompt_tokens,
+                completion_tokens,
+                total_cost,
+                prompt_cost,
+                completion_cost,
+            ) in await session.stream(stmt):
+                cost_summary = SpanCostSummary(
+                    prompt=CostBreakdown(tokens=prompt_tokens, cost=prompt_cost),
+                    completion=CostBreakdown(tokens=completion_tokens, cost=completion_cost),
+                    total=CostBreakdown(tokens=total_tokens, cost=total_cost),
+                )
+                cache_time_range = TimeRange(
+                    start=time_range.start,
+                    end=time_range.end,
+                )
+                gql_model = to_gql_generative_model(model)
+                gql_model.add_cached_cost_summary(
+                    self.project_rowid, cache_time_range, cost_summary
+                )
+                results.append(gql_model)
+            return results
+
 
 @strawberry.type
 class SpanCountTimeSeriesDataPoint:

arize_phoenix-11.11.0/src/phoenix/server/static/.vite/manifest.json

@@ -0,0 +1,87 @@
+{
+  "_components-B7lK-RgC.js": {
+    "file": "assets/components-B7lK-RgC.js",
+    "name": "components",
+    "imports": [
+      "_vendor-uWG2jYEi.js",
+      "_pages-CnVg_GUi.js",
+      "_vendor-arizeai-CXCKGfvH.js",
+      "_vendor-codemirror-DWr46-WB.js",
+      "_vendor-three-C5WAXd5r.js"
+    ]
+  },
+  "_pages-CnVg_GUi.js": {
+    "file": "assets/pages-CnVg_GUi.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-uWG2jYEi.js",
+      "_vendor-arizeai-CXCKGfvH.js",
+      "_components-B7lK-RgC.js",
+      "_vendor-codemirror-DWr46-WB.js",
+      "_vendor-recharts-0Yf6lanX.js"
+    ]
+  },
+  "_vendor-CqDb5u4o.css": {
+    "file": "assets/vendor-CqDb5u4o.css",
+    "src": "_vendor-CqDb5u4o.css"
+  },
+  "_vendor-arizeai-CXCKGfvH.js": {
+    "file": "assets/vendor-arizeai-CXCKGfvH.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-uWG2jYEi.js"
+    ]
+  },
+  "_vendor-codemirror-DWr46-WB.js": {
+    "file": "assets/vendor-codemirror-DWr46-WB.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-uWG2jYEi.js",
+      "_vendor-shiki-Caei6iKO.js"
+    ]
+  },
+  "_vendor-recharts-0Yf6lanX.js": {
+    "file": "assets/vendor-recharts-0Yf6lanX.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-uWG2jYEi.js"
+    ]
+  },
+  "_vendor-shiki-Caei6iKO.js": {
+    "file": "assets/vendor-shiki-Caei6iKO.js",
+    "name": "vendor-shiki",
+    "imports": [
+      "_vendor-uWG2jYEi.js"
+    ]
+  },
+  "_vendor-three-C5WAXd5r.js": {
+    "file": "assets/vendor-three-C5WAXd5r.js",
+    "name": "vendor-three"
+  },
+  "_vendor-uWG2jYEi.js": {
+    "file": "assets/vendor-uWG2jYEi.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-C5WAXd5r.js"
+    ],
+    "css": [
+      "assets/vendor-CqDb5u4o.css"
+    ]
+  },
+  "index.tsx": {
+    "file": "assets/index-CpePoyTU.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-uWG2jYEi.js",
+      "_vendor-arizeai-CXCKGfvH.js",
+      "_pages-CnVg_GUi.js",
+      "_components-B7lK-RgC.js",
+      "_vendor-three-C5WAXd5r.js",
+      "_vendor-codemirror-DWr46-WB.js",
+      "_vendor-shiki-Caei6iKO.js",
+      "_vendor-recharts-0Yf6lanX.js"
+    ]
+  }
+}