arize-phoenix 5.10.0__py3-none-any.whl → 5.12.0__py3-none-any.whl

phoenix/server/api/mutations/chat_mutations.py

@@ -1,9 +1,9 @@
 import asyncio
 from dataclasses import asdict, field
 from datetime import datetime, timezone
-from itertools import chain
+from itertools import chain, islice
 from traceback import format_exc
-from typing import Any, Iterable, Iterator, List, Optional, Union
+from typing import Any, Iterable, Iterator, List, Optional, TypeVar, Union
 
 import strawberry
 from openinference.instrumentation import safe_json_dumps
@@ -25,8 +25,9 @@ from typing_extensions import assert_never
 from phoenix.datetime_utils import local_now, normalize_datetime
 from phoenix.db import models
 from phoenix.db.helpers import get_dataset_example_revisions
+from phoenix.server.api.auth import IsNotReadOnly
 from phoenix.server.api.context import Context
-from phoenix.server.api.exceptions import BadRequest, NotFound
+from phoenix.server.api.exceptions import BadRequest, CustomGraphQLError, NotFound
 from phoenix.server.api.helpers.playground_clients import (
     PlaygroundStreamingClient,
     initialize_playground_clients,
@@ -67,6 +68,7 @@ from phoenix.utilities.json import jsonify
 from phoenix.utilities.template_formatters import (
     FStringTemplateFormatter,
     MustacheTemplateFormatter,
+    NoOpFormatter,
     TemplateFormatter,
 )
 
@@ -117,7 +119,7 @@ class ChatCompletionOverDatasetMutationPayload:
 
 @strawberry.type
 class ChatCompletionMutationMixin:
-    @strawberry.mutation
+    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore
     @classmethod
     async def chat_completion_over_dataset(
         cls,
@@ -127,11 +129,19 @@ class ChatCompletionMutationMixin:
         provider_key = input.model.provider_key
         llm_client_class = PLAYGROUND_CLIENT_REGISTRY.get_client(provider_key, input.model.name)
         if llm_client_class is None:
-            raise BadRequest(f"No LLM client registered for provider '{provider_key}'")
-        llm_client = llm_client_class(
-            model=input.model,
-            api_key=input.api_key,
-        )
+            raise BadRequest(f"Unknown LLM provider: '{provider_key.value}'")
+        try:
+            llm_client = llm_client_class(
+                model=input.model,
+                api_key=input.api_key,
+            )
+        except CustomGraphQLError:
+            raise
+        except Exception as error:
+            raise BadRequest(
+                f"Failed to connect to LLM API for {provider_key.value} {input.model.name}: "
+                f"{str(error)}"
+            )
         dataset_id = from_global_id_with_expected_type(input.dataset_id, Dataset.__name__)
         dataset_version_id = (
             from_global_id_with_expected_type(
@@ -158,7 +168,9 @@ class ChatCompletionMutationMixin:
             revisions = [
                 revision
                 async for revision in await session.stream_scalars(
-                    get_dataset_example_revisions(resolved_version_id)
+                    get_dataset_example_revisions(resolved_version_id).order_by(
+                        models.DatasetExampleRevision.id
+                    )
                 )
             ]
             if not revisions:
@@ -181,28 +193,32 @@ class ChatCompletionMutationMixin:
             session.add(experiment)
             await session.flush()
 
+        results = []
+        batch_size = 3
         start_time = datetime.now(timezone.utc)
-        results = await asyncio.gather(
-            *(
-                cls._chat_completion(
-                    info,
-                    llm_client,
-                    ChatCompletionInput(
-                        model=input.model,
-                        api_key=input.api_key,
-                        messages=input.messages,
-                        tools=input.tools,
-                        invocation_parameters=input.invocation_parameters,
-                        template=TemplateOptions(
-                            language=input.template_language,
-                            variables=revision.input,
+        for batch in _get_batches(revisions, batch_size):
+            batch_results = await asyncio.gather(
+                *(
+                    cls._chat_completion(
+                        info,
+                        llm_client,
+                        ChatCompletionInput(
+                            model=input.model,
+                            api_key=input.api_key,
+                            messages=input.messages,
+                            tools=input.tools,
+                            invocation_parameters=input.invocation_parameters,
+                            template=TemplateOptions(
+                                language=input.template_language,
+                                variables=revision.input,
+                            ),
                         ),
-                    ),
-                )
-                for revision in revisions
-            ),
-            return_exceptions=True,
-        )
+                    )
+                    for revision in batch
+                ),
+                return_exceptions=True,
+            )
+            results.extend(batch_results)
 
         payload = ChatCompletionOverDatasetMutationPayload(
             dataset_id=GlobalID(models.Dataset.__name__, str(dataset.id)),
@@ -258,7 +274,7 @@ class ChatCompletionMutationMixin:
             payload.examples.append(example_payload)
         return payload
 
-    @strawberry.mutation
+    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore
     @classmethod
     async def chat_completion(
         cls, info: Info[Context, None], input: ChatCompletionInput
@@ -266,11 +282,19 @@ class ChatCompletionMutationMixin:
         provider_key = input.model.provider_key
         llm_client_class = PLAYGROUND_CLIENT_REGISTRY.get_client(provider_key, input.model.name)
         if llm_client_class is None:
-            raise BadRequest(f"No LLM client registered for provider '{provider_key}'")
-        llm_client = llm_client_class(
-            model=input.model,
-            api_key=input.api_key,
-        )
+            raise BadRequest(f"Unknown LLM provider: '{provider_key.value}'")
+        try:
+            llm_client = llm_client_class(
+                model=input.model,
+                api_key=input.api_key,
+            )
+        except CustomGraphQLError:
+            raise
+        except Exception as error:
+            raise BadRequest(
+                f"Failed to connect to LLM API for {provider_key.value} {input.model.name}: "
+                f"{str(error)}"
+            )
         return await cls._chat_completion(info, llm_client, input)
 
     @classmethod
@@ -459,6 +483,8 @@ def _template_formatter(template_language: TemplateLanguage) -> TemplateFormatte
         return MustacheTemplateFormatter()
     if template_language is TemplateLanguage.F_STRING:
         return FStringTemplateFormatter()
+    if template_language is TemplateLanguage.NONE:
+        return NoOpFormatter()
     assert_never(template_language)
 
 
@@ -486,6 +512,11 @@ def _llm_output_messages(
     if text_content:
         yield f"{LLM_OUTPUT_MESSAGES}.0.{MESSAGE_CONTENT}", text_content
     for tool_call_index, tool_call in enumerate(tool_calls.values()):
+        if tool_call_id := tool_call.id:
+            yield (
+                f"{LLM_OUTPUT_MESSAGES}.0.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_ID}",
+                tool_call_id,
+            )
         yield (
             f"{LLM_OUTPUT_MESSAGES}.0.{MESSAGE_TOOL_CALLS}.{tool_call_index}.{TOOL_CALL_FUNCTION_NAME}",
             tool_call.function.name,
@@ -513,6 +544,19 @@ def _serialize_event(event: SpanException) -> dict[str, Any]:
     return {k: (v.isoformat() if isinstance(v, datetime) else v) for k, v in asdict(event).items()}
 
 
+_AnyT = TypeVar("_AnyT")
+
+
+def _get_batches(
+    iterable: Iterable[_AnyT],
+    batch_size: int,
+) -> Iterator[list[_AnyT]]:
+    """Splits an iterable into batches not exceeding a specified size."""
+    iterator = iter(iterable)
+    while batch := list(islice(iterator, batch_size)):
+        yield batch
+
+
 JSON = OpenInferenceMimeTypeValues.JSON.value
 TEXT = OpenInferenceMimeTypeValues.TEXT.value
 LLM = OpenInferenceSpanKindValues.LLM.value
@@ -534,6 +578,7 @@ MESSAGE_CONTENT = MessageAttributes.MESSAGE_CONTENT
 MESSAGE_ROLE = MessageAttributes.MESSAGE_ROLE
 MESSAGE_TOOL_CALLS = MessageAttributes.MESSAGE_TOOL_CALLS
 
+TOOL_CALL_ID = ToolCallAttributes.TOOL_CALL_ID
 TOOL_CALL_FUNCTION_NAME = ToolCallAttributes.TOOL_CALL_FUNCTION_NAME
 TOOL_CALL_FUNCTION_ARGUMENTS_JSON = ToolCallAttributes.TOOL_CALL_FUNCTION_ARGUMENTS_JSON
 

phoenix/server/api/subscriptions.py

@@ -1,10 +1,11 @@
 import asyncio
 import logging
-from asyncio import FIRST_COMPLETED, Queue, QueueEmpty, Task, create_task, wait, wait_for
 from collections.abc import AsyncIterator, Iterator
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import (
     Any,
+    AsyncGenerator,
+    Coroutine,
     Iterable,
     Mapping,
     Optional,
@@ -23,8 +24,9 @@ from typing_extensions import TypeAlias, assert_never
 
 from phoenix.datetime_utils import local_now, normalize_datetime
 from phoenix.db import models
+from phoenix.server.api.auth import IsNotReadOnly
 from phoenix.server.api.context import Context
-from phoenix.server.api.exceptions import BadRequest, NotFound
+from phoenix.server.api.exceptions import BadRequest, CustomGraphQLError, NotFound
 from phoenix.server.api.helpers.playground_clients import (
     PlaygroundStreamingClient,
     initialize_playground_clients,
@@ -62,6 +64,7 @@ from phoenix.server.types import DbSessionFactory
 from phoenix.utilities.template_formatters import (
     FStringTemplateFormatter,
     MustacheTemplateFormatter,
+    NoOpFormatter,
     TemplateFormatter,
     TemplateFormatterError,
 )
@@ -79,23 +82,32 @@ DatasetExampleID: TypeAlias = GlobalID
 ChatCompletionResult: TypeAlias = tuple[
     DatasetExampleID, Optional[models.Span], models.ExperimentRun
 ]
+ChatStream: TypeAlias = AsyncGenerator[ChatCompletionSubscriptionPayload, None]
 PLAYGROUND_PROJECT_NAME = "playground"
 
 
 @strawberry.type
 class Subscription:
-    @strawberry.subscription
+    @strawberry.subscription(permission_classes=[IsNotReadOnly])  # type: ignore
     async def chat_completion(
         self, info: Info[Context, None], input: ChatCompletionInput
     ) -> AsyncIterator[ChatCompletionSubscriptionPayload]:
         provider_key = input.model.provider_key
         llm_client_class = PLAYGROUND_CLIENT_REGISTRY.get_client(provider_key, input.model.name)
         if llm_client_class is None:
-            raise BadRequest(f"No LLM client registered for provider '{provider_key}'")
-        llm_client = llm_client_class(
-            model=input.model,
-            api_key=input.api_key,
-        )
+            raise BadRequest(f"Unknown LLM provider: '{provider_key.value}'")
+        try:
+            llm_client = llm_client_class(
+                model=input.model,
+                api_key=input.api_key,
+            )
+        except CustomGraphQLError:
+            raise
+        except Exception as error:
+            raise BadRequest(
+                f"Failed to connect to LLM API for {provider_key.value} {input.model.name}: "
+                f"{str(error)}"
+            )
 
         messages = [
             (
@@ -151,14 +163,26 @@ class Subscription:
         info.context.event_queue.put(SpanInsertEvent(ids=(playground_project_id,)))
         yield ChatCompletionSubscriptionResult(span=to_gql_span(db_span))
 
-    @strawberry.subscription
+    @strawberry.subscription(permission_classes=[IsNotReadOnly])  # type: ignore
     async def chat_completion_over_dataset(
         self, info: Info[Context, None], input: ChatCompletionOverDatasetInput
     ) -> AsyncIterator[ChatCompletionSubscriptionPayload]:
         provider_key = input.model.provider_key
         llm_client_class = PLAYGROUND_CLIENT_REGISTRY.get_client(provider_key, input.model.name)
         if llm_client_class is None:
-            raise BadRequest(f"No LLM client registered for provider '{provider_key}'")
+            raise BadRequest(f"Unknown LLM provider: '{provider_key.value}'")
+        try:
+            llm_client = llm_client_class(
+                model=input.model,
+                api_key=input.api_key,
+            )
+        except CustomGraphQLError:
+            raise
+        except Exception as error:
+            raise BadRequest(
+                f"Failed to connect to LLM API for {provider_key.value} {input.model.name}: "
+                f"{str(error)}"
+            )
 
         dataset_id = from_global_id_with_expected_type(input.dataset_id, Dataset.__name__)
         version_id = (
@@ -264,45 +288,82 @@ class Subscription:
             experiment=to_gql_experiment(experiment)
         )  # eagerly yields experiment so it can be linked by consumers of the subscription
 
-        results_queue: Queue[ChatCompletionResult] = Queue()
-        chat_completion_streams = [
-            _stream_chat_completion_over_dataset_example(
-                input=input,
-                llm_client_class=llm_client_class,
-                revision=revision,
-                results_queue=results_queue,
-                experiment_id=experiment.id,
-                project_id=playground_project_id,
+        results: asyncio.Queue[ChatCompletionResult] = asyncio.Queue()
+        not_started: list[tuple[DatasetExampleID, ChatStream]] = [
+            (
+                GlobalID(DatasetExample.__name__, str(revision.dataset_example_id)),
+                _stream_chat_completion_over_dataset_example(
+                    input=input,
+                    llm_client=llm_client,
+                    revision=revision,
+                    results=results,
+                    experiment_id=experiment.id,
+                    project_id=playground_project_id,
+                ),
             )
             for revision in revisions
         ]
-        stream_to_async_tasks: dict[
-            AsyncIterator[ChatCompletionSubscriptionPayload],
-            Task[ChatCompletionSubscriptionPayload],
-        ] = {iterator: _create_task_with_timeout(iterator) for iterator in chat_completion_streams}
-        batch_size = 10
-        while stream_to_async_tasks:
-            async_tasks_to_run = [task for task in stream_to_async_tasks.values()]
-            completed_tasks, _ = await wait(async_tasks_to_run, return_when=FIRST_COMPLETED)
-            for task in completed_tasks:
-                iterator = next(it for it, t in stream_to_async_tasks.items() if t == task)
+        in_progress: list[
+            tuple[
+                Optional[DatasetExampleID],
+                ChatStream,
+                asyncio.Task[ChatCompletionSubscriptionPayload],
+            ]
+        ] = []
+        max_in_progress = 3
+        write_batch_size = 10
+        write_interval = timedelta(seconds=10)
+        last_write_time = datetime.now()
+        while not_started or in_progress:
+            while not_started and len(in_progress) < max_in_progress:
+                ex_id, stream = not_started.pop()
+                task = _create_task_with_timeout(stream)
+                in_progress.append((ex_id, stream, task))
+            async_tasks_to_run = [task for _, _, task in in_progress]
+            completed_tasks, _ = await asyncio.wait(
+                async_tasks_to_run, return_when=asyncio.FIRST_COMPLETED
+            )
+            for completed_task in completed_tasks:
+                idx = [task for _, _, task in in_progress].index(completed_task)
+                example_id, stream, _ = in_progress[idx]
                 try:
-                    yield task.result()
-                except (StopAsyncIteration, asyncio.TimeoutError):
-                    del stream_to_async_tasks[iterator]  # removes exhausted iterator
+                    yield completed_task.result()
+                except StopAsyncIteration:
+                    del in_progress[idx]  # removes exhausted stream
+                except asyncio.TimeoutError:
+                    del in_progress[idx]  # removes timed-out stream
+                    if example_id is not None:
+                        yield ChatCompletionSubscriptionError(
+                            message="Playground task timed out", dataset_example_id=example_id
+                        )
                 except Exception as error:
-                    del stream_to_async_tasks[iterator]  # removes failed iterator
+                    del in_progress[idx]  # removes failed stream
+                    if example_id is not None:
+                        yield ChatCompletionSubscriptionError(
+                            message="An unexpected error occurred", dataset_example_id=example_id
+                        )
                     logger.exception(error)
                 else:
-                    stream_to_async_tasks[iterator] = _create_task_with_timeout(iterator)
-                if results_queue.qsize() >= batch_size:
-                    result_iterator = _chat_completion_result_payloads(
-                        db=info.context.db, results=_drain_no_wait(results_queue)
-                    )
-                    stream_to_async_tasks[result_iterator] = _create_task_with_timeout(
-                        result_iterator
+                    task = _create_task_with_timeout(stream)
+                    in_progress[idx] = (example_id, stream, task)
+
+                exceeded_write_batch_size = results.qsize() >= write_batch_size
+                exceeded_write_interval = datetime.now() - last_write_time > write_interval
+                write_already_in_progress = any(
+                    _is_result_payloads_stream(stream) for _, stream, _ in in_progress
+                )
+                if (
+                    not results.empty()
+                    and (exceeded_write_batch_size or exceeded_write_interval)
+                    and not write_already_in_progress
+                ):
+                    result_payloads_stream = _chat_completion_result_payloads(
+                        db=info.context.db, results=_drain_no_wait(results)
                     )
-        if remaining_results := await _drain(results_queue):
+                    task = _create_task_with_timeout(result_payloads_stream)
+                    in_progress.append((None, result_payloads_stream, task))
+                    last_write_time = datetime.now()
+        if remaining_results := await _drain(results):
             async for result_payload in _chat_completion_result_payloads(
                 db=info.context.db, results=remaining_results
             ):
@@ -312,17 +373,13 @@ class Subscription:
 async def _stream_chat_completion_over_dataset_example(
     *,
     input: ChatCompletionOverDatasetInput,
-    llm_client_class: type["PlaygroundStreamingClient"],
+    llm_client: PlaygroundStreamingClient,
     revision: models.DatasetExampleRevision,
-    results_queue: Queue[ChatCompletionResult],
+    results: asyncio.Queue[ChatCompletionResult],
     experiment_id: int,
     project_id: int,
-) -> AsyncIterator[ChatCompletionSubscriptionPayload]:
+) -> ChatStream:
     example_id = GlobalID(DatasetExample.__name__, str(revision.dataset_example_id))
-    llm_client = llm_client_class(
-        model=input.model,
-        api_key=input.api_key,
-    )
     invocation_parameters = llm_client.construct_invocation_parameters(input.invocation_parameters)
     messages = [
         (
@@ -345,7 +402,7 @@ async def _stream_chat_completion_over_dataset_example(
     except TemplateFormatterError as error:
         format_end_time = cast(datetime, normalize_datetime(dt=local_now(), tz=timezone.utc))
         yield ChatCompletionSubscriptionError(message=str(error), dataset_example_id=example_id)
-        await results_queue.put(
+        await results.put(
             (
                 example_id,
                 None,
@@ -380,7 +437,7 @@ async def _stream_chat_completion_over_dataset_example(
     db_run = get_db_experiment_run(
         db_span, db_trace, experiment_id=experiment_id, example_id=revision.dataset_example_id
     )
-    await results_queue.put((example_id, db_span, db_run))
+    await results.put((example_id, db_span, db_run))
     if span.status_message is not None:
         yield ChatCompletionSubscriptionError(
             message=span.status_message, dataset_example_id=example_id
@@ -391,7 +448,7 @@ async def _chat_completion_result_payloads(
     *,
     db: DbSessionFactory,
     results: Sequence[ChatCompletionResult],
-) -> AsyncIterator[ChatCompletionSubscriptionResult]:
+) -> ChatStream:
     if not results:
         return
     async with db() as session:
@@ -408,25 +465,64 @@ async def _chat_completion_result_payloads(
         )
 
 
+def _is_result_payloads_stream(
+    stream: ChatStream,
+) -> bool:
+    """
+    Checks if the given generator was instantiated from
+    `_chat_completion_result_payloads`
+    """
+    return stream.ag_code == _chat_completion_result_payloads.__code__
+
+
 def _create_task_with_timeout(
-    iterable: AsyncIterator[GenericType], timeout_in_seconds: int = 60
-) -> Task[GenericType]:
-    return create_task(wait_for(_as_coroutine(iterable), timeout=timeout_in_seconds))
+    iterable: AsyncIterator[GenericType], timeout_in_seconds: int = 90
+) -> asyncio.Task[GenericType]:
+    return asyncio.create_task(
+        _wait_for(
+            _as_coroutine(iterable),
+            timeout=timeout_in_seconds,
+            timeout_message="Playground task timed out",
+        )
+    )
+
+
+async def _wait_for(
+    coro: Coroutine[None, None, GenericType],
+    timeout: float,
+    timeout_message: Optional[str] = None,
+) -> GenericType:
+    """
+    A function that imitates asyncio.wait_for, but allows the task to be
+    cancelled with a custom message.
+    """
+    task = asyncio.create_task(coro)
+    done, pending = await asyncio.wait([task], timeout=timeout)
+    assert len(done) + len(pending) == 1
+    if done:
+        task = done.pop()
+        return task.result()
+    task = pending.pop()
+    task.cancel(msg=timeout_message)
+    try:
+        return await task
+    except asyncio.CancelledError:
+        raise asyncio.TimeoutError()
 
 
-async def _drain(queue: Queue[GenericType]) -> list[GenericType]:
+async def _drain(queue: asyncio.Queue[GenericType]) -> list[GenericType]:
     values: list[GenericType] = []
     while not queue.empty():
         values.append(await queue.get())
     return values
 
 
-def _drain_no_wait(queue: Queue[GenericType]) -> list[GenericType]:
+def _drain_no_wait(queue: asyncio.Queue[GenericType]) -> list[GenericType]:
     values: list[GenericType] = []
     while True:
         try:
             values.append(queue.get_nowait())
-        except QueueEmpty:
+        except asyncio.QueueEmpty:
             break
     return values
 
@@ -467,6 +563,8 @@ def _template_formatter(template_language: TemplateLanguage) -> TemplateFormatte
         return MustacheTemplateFormatter()
     if template_language is TemplateLanguage.F_STRING:
         return FStringTemplateFormatter()
+    if template_language is TemplateLanguage.NONE:
+        return NoOpFormatter()
     assert_never(template_language)
 
 

phoenix/server/api/types/TemplateLanguage.py

@@ -5,5 +5,6 @@ import strawberry
 
 @strawberry.enum
 class TemplateLanguage(Enum):
+    NONE = "NONE"
     MUSTACHE = "MUSTACHE"
     F_STRING = "F_STRING"

phoenix/server/static/.vite/manifest.json

@@ -1,32 +1,32 @@
 {
-  "_components-BXIz9ZO8.js": {
-    "file": "assets/components-BXIz9ZO8.js",
+  "_components-72cQL1d1.js": {
+    "file": "assets/components-72cQL1d1.js",
     "name": "components",
     "imports": [
-      "_vendor-BX8_Znqy.js",
-      "_pages-B8FpJuXu.js",
-      "_vendor-arizeai-CtHir-Ua.js",
-      "_vendor-codemirror-DLlGiguX.js",
+      "_vendor-DexmGnha.js",
+      "_pages-DFAkBAUh.js",
+      "_vendor-arizeai--Q3ol330.js",
+      "_vendor-codemirror-B4bYvWa6.js",
       "_vendor-three-DwGkEfCM.js"
     ]
   },
-  "_pages-B8FpJuXu.js": {
-    "file": "assets/pages-B8FpJuXu.js",
+  "_pages-DFAkBAUh.js": {
+    "file": "assets/pages-DFAkBAUh.js",
     "name": "pages",
     "imports": [
-      "_vendor-BX8_Znqy.js",
-      "_vendor-arizeai-CtHir-Ua.js",
-      "_components-BXIz9ZO8.js",
-      "_vendor-recharts-CJRple0d.js",
-      "_vendor-codemirror-DLlGiguX.js"
+      "_vendor-DexmGnha.js",
+      "_vendor-arizeai--Q3ol330.js",
+      "_components-72cQL1d1.js",
+      "_vendor-recharts-B4ZzJhNh.js",
+      "_vendor-codemirror-B4bYvWa6.js"
     ]
   },
   "_vendor-!~{003}~.js": {
     "file": "assets/vendor-DxkFTwjz.css",
     "src": "_vendor-!~{003}~.js"
   },
-  "_vendor-BX8_Znqy.js": {
-    "file": "assets/vendor-BX8_Znqy.js",
+  "_vendor-DexmGnha.js": {
+    "file": "assets/vendor-DexmGnha.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-DwGkEfCM.js"
@@ -35,25 +35,25 @@
       "assets/vendor-DxkFTwjz.css"
     ]
   },
-  "_vendor-arizeai-CtHir-Ua.js": {
-    "file": "assets/vendor-arizeai-CtHir-Ua.js",
+  "_vendor-arizeai--Q3ol330.js": {
+    "file": "assets/vendor-arizeai--Q3ol330.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-BX8_Znqy.js"
+      "_vendor-DexmGnha.js"
     ]
   },
-  "_vendor-codemirror-DLlGiguX.js": {
-    "file": "assets/vendor-codemirror-DLlGiguX.js",
+  "_vendor-codemirror-B4bYvWa6.js": {
+    "file": "assets/vendor-codemirror-B4bYvWa6.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-BX8_Znqy.js"
+      "_vendor-DexmGnha.js"
     ]
   },
-  "_vendor-recharts-CJRple0d.js": {
-    "file": "assets/vendor-recharts-CJRple0d.js",
+  "_vendor-recharts-B4ZzJhNh.js": {
+    "file": "assets/vendor-recharts-B4ZzJhNh.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-BX8_Znqy.js"
+      "_vendor-DexmGnha.js"
     ]
   },
   "_vendor-three-DwGkEfCM.js": {
@@ -61,18 +61,18 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-DTut7g1y.js",
+    "file": "assets/index-BowjltW-.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-BX8_Znqy.js",
-      "_vendor-arizeai-CtHir-Ua.js",
-      "_pages-B8FpJuXu.js",
-      "_components-BXIz9ZO8.js",
+      "_vendor-DexmGnha.js",
+      "_vendor-arizeai--Q3ol330.js",
+      "_pages-DFAkBAUh.js",
+      "_components-72cQL1d1.js",
       "_vendor-three-DwGkEfCM.js",
-      "_vendor-recharts-CJRple0d.js",
-      "_vendor-codemirror-DLlGiguX.js"
+      "_vendor-recharts-B4ZzJhNh.js",
+      "_vendor-codemirror-B4bYvWa6.js"
     ]
   }
 }