:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(aio): serve trace node detail from a node resource (#120146)
Carlos Marchalb9f3c258c55f
diff --git a/frontend/snapshots.yml b/frontend/snapshots.ymlindex 54997972c0ed..91b75822308a 100644--- a/frontend/snapshots.yml+++ b/frontend/snapshots.yml@@ -9175,9 +9175,13 @@ snapshots:scenes-app-ai-observability-trace-view-message-part--tool-call-multiline-args--light:hash: v1.k794b7964.9574ac70d0b3fcabc0a60c1fb7b677ceb53a636337094f215b45862c289c8ee8.oELNCo2z_5ClcAdMZJArSx-p3v0tTepDm2JSRpUOC_Yscenes-app-ai-observability-trace-view-node-detail--content-load-error--dark:- hash: v1.k794b7964.f8fdba7601160c5e3ae32e997e2b571c43ee4735a5d3164a18af1fc387b830e9.v1Ybpavq8kWeP78qkS3yCKLOvhwNJK2C8fYLrLadHpE+ hash: v1.k794b7964.5e36d3da09795c3413edf6908a4e90314fceb472621916dbb6de77ac40ac2a48.MayzNXkmRuKZfIU9L-TAGE67PKAPgJcY6R1UaTw1CRYscenes-app-ai-observability-trace-view-node-detail--content-load-error--light:- hash: v1.k794b7964.9c41bf277ca69973253ee4511786bb860e3b41c3136e7642956f1cc2f3478099.NGDcm0HC3GXzNonYv7TeTVtn696qxLC1DswZcApxOyw+ hash: v1.k794b7964.888a327ae27d5d8ffe6cfde13c9b1871dddf48915a8957787a92f89017fc3ed9._CuQ3SAqbn5iQYF-gsQhWQPCWOjRw5gywJsKBzXZdH0+ scenes-app-ai-observability-trace-view-node-detail--content-not-found--dark:+ hash: v1.k794b7964.aa5f2ea36c16d32009ed51721b09b89687f10d6752c2244c0030240154736b9d.h1bZtLYGaahqQMGZ99NcWY4WezCo324_wg9Qr4sjH3o+ scenes-app-ai-observability-trace-view-node-detail--content-not-found--light:+ hash: v1.k794b7964.d5221fe9b3ba087f1d8715258424d71707ee37b9a2817adef30216272914353b.ZS6oiD8HREwTLnh0qdgNV7IU6TaoG5ryyrBMC6BbDzIscenes-app-ai-observability-trace-view-node-detail--evals-load-error--dark:hash: v1.k794b7964.8e974f8628c9cc06a2f376f029a8d4d1e5e6755bfc4e15cf1425d50ac27d5507.8xlC3RbKsMdoSiqaBI0oIq7qF844Mjm5g4b4yhjjEKAscenes-app-ai-observability-trace-view-node-detail--evals-load-error--light:@@ -9210,6 +9214,10 @@ snapshots:hash: v1.k794b7964.190b2c059d38d9a4716b35b1e9c40289f527206b095aa1751f36c57b1a08f83f.CYx8ZM77Xrh0mipyOxjxDW89lmpREnNVg_WJG6JB5pkscenes-app-ai-observability-trace-view-node-detail--nothing-captured--light:hash: v1.k794b7964.c25dcd37e1256ce57a18d5b14719b431c974fe360b9097bc25628354f3f65b2e.UJizBxDMm7WoFJWlPPo6jv_tswAx-pRdrF5wuFpXs5Y+ scenes-app-ai-observability-trace-view-node-detail--raw-tab-while-loading--dark:+ hash: v1.k794b7964.18cf781434dc68c49196fc46b7b7e741d8bbaf988f969e87cddba444dda970dc.JlcKvloACxrmr1NHcJP1U9fCvsgwg0WzigUF25xx0BM+ scenes-app-ai-observability-trace-view-node-detail--raw-tab-while-loading--light:+ hash: v1.k794b7964.963ea7f1028cf1cac01798ba8a9666073a119fb9a80500e9f0f8138e030f9ac0.faMrLWo2r8TFBrRAi_DApZcAJ4r6AwhCiSt_GZEsXxYscenes-app-ai-observability-trace-view-node-detail--span-details-tab--dark:hash: v1.k794b7964.c8765f600847c62e2d29705c6833a4e43707668a4c53f57e918e8c958e25d401.KDRSsssfGhhPMk88hskuIT4xCo_HEmeHTjs17yqXbaMscenes-app-ai-observability-trace-view-node-detail--span-details-tab--light:@@ -9266,6 +9274,10 @@ snapshots:hash: v1.k794b7964.f5b92092a059f22776c712b8afec2b4fa99a51f7f733fdc918cd2f288920570f.O_OKuMlShlDsZtzN8ld1vQhh1wMlc9UfPqwwgnWLc6oscenes-app-ai-observability-trace-view-raw-event--default--light:hash: v1.k794b7964.6feab338f432d042f8e53f328dc7709cdc79bd2fda46b6274db876c9c3ef078b.R-d9RNKhCeOY388cXbLAQhzde0lPGMMo-Dfbk3gRf6Q+ scenes-app-ai-observability-trace-view-raw-event--no-trace-event--dark:+ hash: v1.k794b7964.bda2d5985bf7439273c42268b1279aa6eb2fee37e1aaafb4c199e98b1a8b7e94.oySozMrViJSTs1dyaKsz_3EdiTOd9MBj91nk8MO71fc+ scenes-app-ai-observability-trace-view-raw-event--no-trace-event--light:+ hash: v1.k794b7964.4a4e729043d00b03247ce25fe10de02bc132f3811c6c288032abcd36ed2fea03.REnmV4U-vFpxUJB4Lfun1zLM9Tf8tvqFDafAwrTYKeoscenes-app-ai-observability-trace-view-thread--anthropic-thinking-and-tools--dark:hash: v1.k794b7964.b3d0fe41e4ce3167d04d9c3f1fdb4b25414b9c27f3d9b26dc4122e5490b97663.rVseBKdzxKu43YsBqrE-cO9KxX7roQd9qLgsEj49jPoscenes-app-ai-observability-trace-view-thread--anthropic-thinking-and-tools--light:@@ -9282,6 +9294,10 @@ snapshots:hash: v1.k794b7964.10d636c7559a25e66b17140445ddc81e64c86227a53777de3361b3e3139b6fcd.Iv_7m3XW9y78EXvDCTLNfk-hmv7aJIGEuj-Ydq9ElP0scenes-app-ai-observability-trace-view-thread--image-input-with-error--light:hash: v1.k794b7964.427c25b2c17800207a09b427bd5022fc7c35a66d89b7485bcde127137a410cec.Tb6OzKrK5aukGNqRLLegxDIi6Qe_JGpImEX8rqPMD3s+ scenes-app-ai-observability-trace-view-thread--load-error--dark:+ hash: v1.k794b7964.833678e26fd6966ee891cb56f241ea7a49ca1481c2639c973eec48bb1f4faf28.a-7RiKkuaazD7C3uM4sG6lZLckC9f9SYc0Yyn6LAES4+ scenes-app-ai-observability-trace-view-thread--load-error--light:+ hash: v1.k794b7964.093afa3e6bb6a4e7bbbf07e575d729555242d2c50c2ed1d555fdcec683c9bbc7.ohzNaMQSSLTTH2R84l_YIFyh9Ak2wa5e8PtoGlk2Licscenes-app-ai-observability-trace-view-thread--loading--dark:hash: v1.k794b7964.d19bc82013117a8c7c4eab890f02c545447f1f6bc1fb8dc60ab23a03fe2aaabe.qKU9q9cnJS-tZNtvV9U5Kf4gXB1BgxYq1Y6LYzWJnKEscenes-app-ai-observability-trace-view-thread--loading--light:diff --git a/products/ai_observability/backend/facade/api.py b/products/ai_observability/backend/facade/api.pyindex 6b3033f9a66e..6c012cfd5202 100644--- a/products/ai_observability/backend/facade/api.py+++ b/products/ai_observability/backend/facade/api.py@@ -3,9 +3,11 @@ from datetime import datetimefrom posthog.models import Team, Userfrom ..logic.evaluations.pass_filters import build_evaluation_pass_filters+from ..logic.traces.events_fallback import fallback_window+from ..logic.traces.node import NodeEventfrom ..logic.traces.timeline import TimelineRowfrom ..logic.traces.trace import Trace-from ..logic.traces.trace_queries import fallback_window, load_trace+from ..logic.traces.trace_queries import load_trace, load_trace_node, load_trace_rootfrom ..logic.traces.tree import TreeNodefrom ..logic.traces.usage import Usagefrom . import contracts@@ -15,6 +17,15 @@ class TraceNotFoundError(Exception):pass+class TraceNodeNotFoundError(Exception):+ pass+++_NO_METADATA = contracts.TraceNodeMetadata(+ provider=None, temperature=None, session_id=None, prompt_name=None, prompt_version=None+)++def is_usable_timestamp_hint(timestamp_hint: datetime) -> bool:try:fallback_window(timestamp_hint)@@ -30,6 +41,22 @@ def get_trace(team: Team, user: User | None, trace_id: str, timestamp_hint: datereturn _to_trace(Trace(trace_id, loaded.rows, loaded.person))+def get_trace_node(+ team: Team, user: User | None, trace_id: str, node_id: str, timestamp_hint: datetime | None+) -> contracts.TraceNodeDetail:+ if node_id == trace_id:+ root = load_trace_root(team, user, trace_id, timestamp_hint)+ if not root.trace_found:+ raise TraceNodeNotFoundError(node_id)+ if root.trace_event is None:+ return contracts.TraceNodeDetail(id=trace_id, kind="trace", error=None, metadata=_NO_METADATA, event=None)+ return _to_node_detail(trace_id, NodeEvent(row=root.trace_event))+ row = load_trace_node(team, user, trace_id, node_id, timestamp_hint)+ if row is None:+ raise TraceNodeNotFoundError(node_id)+ return _to_node_detail(node_id, NodeEvent(row=row))++def _to_stats(usage: Usage) -> contracts.TraceNodeStats:return contracts.TraceNodeStats(cost_usd=usage.cost_usd,@@ -94,6 +121,32 @@ def _to_trace(trace: Trace) -> contracts.Trace:timeline=[_to_timeline_row(row) for row in trace.timeline.rows],total_ms=trace.timeline.total_ms,thread_node_ids=trace.thread_node_ids,+ default_node_id=trace.default_node_id,+ node_ids_by_alias=trace.node_ids_by_alias,+ )+++def _to_node_detail(node_id: str, event: NodeEvent) -> contracts.TraceNodeDetail:+ keys = event.io_keys+ metadata = event.metadata+ return contracts.TraceNodeDetail(+ id=node_id,+ kind=event.kind,+ error=event.error,+ metadata=contracts.TraceNodeMetadata(+ provider=metadata.provider,+ temperature=metadata.temperature,+ session_id=metadata.session_id,+ prompt_name=metadata.prompt_name,+ prompt_version=metadata.prompt_version,+ ),+ event=contracts.TraceNodeEvent(+ name=event.row.event,+ uuid=event.row.uuid,+ timestamp=event.row.timestamp,+ properties=event.row.properties,+ io_keys=contracts.TraceNodeIOKeys(input=keys.input, output=keys.output, tools=keys.tools),+ ),)diff --git a/products/ai_observability/backend/facade/contracts.py b/products/ai_observability/backend/facade/contracts.pyindex 859a9e87b032..9f1669cad03e 100644--- a/products/ai_observability/backend/facade/contracts.py+++ b/products/ai_observability/backend/facade/contracts.py@@ -1,7 +1,7 @@from datetime import datetime-from typing import Literal, get_args+from typing import Any, Literal, get_args-from pydantic import BaseModel, ConfigDict+from pydantic import BaseModel, ConfigDict, Fieldfrom pydantic.alias_generators import to_camel@@ -66,6 +66,42 @@ class Trace(Contract):timeline: list[TraceTimelineRow]total_ms: floatthread_node_ids: list[str]+ default_node_id: str+ node_ids_by_alias: dict[str, str]+++class TraceNodeIOKeys(Contract):+ input: str | None+ output: str | None+ tools: str | None+++class TraceNodeMetadata(Contract):+ provider: str | None+ temperature: float | None+ session_id: str | None+ prompt_name: str | None+ prompt_version: float | None+++class TraceNodeEvent(Contract):+ name: str+ uuid: str+ timestamp: datetime+ properties: dict[str, Any] = Field(+ description="The event's properties as ingested, including its input and output values."+ )+ io_keys: TraceNodeIOKeys = Field(+ description="Which keys of `properties` hold the node's input, output and tools, or null when it has none."+ )+++class TraceNodeDetail(Contract):+ id: str+ kind: TraceNodeKind+ error: str | None+ metadata: TraceNodeMetadata+ event: TraceNodeEvent | Noneclass EvaluationPassFilters(Contract):diff --git a/products/ai_observability/backend/logic/traces/event.py b/products/ai_observability/backend/logic/traces/event.pyindex 89e4bd1ae8c0..c76d5ac1c3f5 100644--- a/products/ai_observability/backend/logic/traces/event.py+++ b/products/ai_observability/backend/logic/traces/event.py@@ -9,6 +9,18 @@ from .usage import UsageANNOTATION_EVENTS = frozenset({"$ai_feedback", "$ai_metric"})+def kind_of_event(event_name: str) -> TraceNodeKind:+ match event_name:+ case "$ai_generation":+ return "generation"+ case "$ai_embedding":+ return "embedding"+ case "$ai_trace":+ return "trace"+ case _:+ return "span"++@frozenclass TraceEvent:row: TraceEventRow@@ -28,15 +40,7 @@ class TraceEvent:@propertydef kind(self) -> TraceNodeKind:- match self.row.event:- case "$ai_generation":- return "generation"- case "$ai_embedding":- return "embedding"- case "$ai_trace":- return "trace"- case _:- return "span"+ return kind_of_event(self.row.event)@propertydef is_trace_event(self) -> bool:diff --git a/products/ai_observability/backend/logic/traces/events_fallback.py b/products/ai_observability/backend/logic/traces/events_fallback.pynew file mode 100644index 000000000000..5ef3d9e5f946--- /dev/null+++ b/products/ai_observability/backend/logic/traces/events_fallback.py@@ -0,0 +1,51 @@+from datetime import UTC, datetime, timedelta++from posthog.hogql import ast++from posthog.dataclasses import frozen++FALLBACK_BEFORE_HINT = timedelta(minutes=10)+FALLBACK_AFTER_HINT = timedelta(days=7)+# The legacy trace view used this date as its default range start when a link carried no timestamp.+UNHINTED_FALLBACK_START = datetime(2025, 1, 10, tzinfo=UTC)+++@frozen+class FallbackWindow:+ start: datetime+ end: datetime+++def fallback_window(timestamp_hint: datetime) -> FallbackWindow:+ """Raises OverflowError when the window around the hint leaves the datetime range."""+ return FallbackWindow(start=timestamp_hint - FALLBACK_BEFORE_HINT, end=timestamp_hint + FALLBACK_AFTER_HINT)+++def unhinted_window() -> FallbackWindow:+ return FallbackWindow(+ start=UNHINTED_FALLBACK_START - FALLBACK_BEFORE_HINT, end=datetime.now(UTC) + FALLBACK_AFTER_HINT+ )+++def events_filter(*, trace_filter: ast.Expr, event_filter: ast.Expr, window: FallbackWindow | None) -> ast.Expr:+ if window is None:+ # The shared events table is not sorted by trace id, so a read without a window must not scan it.+ return ast.Constant(value=False)+ # The events table sorts by event and has no index on uuid, so without the event filter the root's uuid lookup+ # scans every event of the team in the window.+ return ast.And(+ exprs=[+ event_filter,+ trace_filter,+ ast.CompareOperation(+ op=ast.CompareOperationOp.GtEq,+ left=ast.Field(chain=["timestamp"]),+ right=ast.Constant(value=window.start),+ ),+ ast.CompareOperation(+ op=ast.CompareOperationOp.LtEq,+ left=ast.Field(chain=["timestamp"]),+ right=ast.Constant(value=window.end),+ ),+ ]+ )diff --git a/products/ai_observability/backend/logic/traces/node.py b/products/ai_observability/backend/logic/traces/node.pynew file mode 100644index 000000000000..02584052f526--- /dev/null+++ b/products/ai_observability/backend/logic/traces/node.py@@ -0,0 +1,89 @@+import json++from posthog.dataclasses import frozen++from ...facade.contracts import TraceNodeKind+from .event import kind_of_event+from .trace_queries import TraceNodeRow, read_flag, read_number, read_text++FAILED_STEP_MESSAGE = "This step failed."+++@frozen+class IOKeyCandidates:+ input: tuple[str, ...]+ output: tuple[str, ...]+ tools: tuple[str, ...]+++IO_KEY_CANDIDATES: dict[TraceNodeKind, IOKeyCandidates] = {+ "generation": IOKeyCandidates(+ input=("$ai_input",), output=("$ai_output_choices", "$ai_output"), tools=("$ai_tools",)+ ),+ "embedding": IOKeyCandidates(input=("$ai_input",), output=(), tools=()),+ "span": IOKeyCandidates(+ input=("$ai_input", "$ai_input_state"),+ output=("$ai_output_choices", "$ai_output_state", "$ai_output"),+ tools=(),+ ),+ "trace": IOKeyCandidates(+ input=("$ai_input_state", "$ai_input"),+ output=("$ai_output_state", "$ai_output_choices", "$ai_output"),+ tools=(),+ ),+}+++@frozen+class IOKeys:+ input: str | None+ output: str | None+ tools: str | None+++@frozen+class NodeMetadata:+ provider: str | None+ temperature: float | None+ session_id: str | None+ prompt_name: str | None+ prompt_version: float | None+++@frozen+class NodeEvent:+ row: TraceNodeRow++ @property+ def kind(self) -> TraceNodeKind:+ return kind_of_event(self.row.event)++ @property+ def io_keys(self) -> IOKeys:+ candidates = IO_KEY_CANDIDATES[self.kind]+ return IOKeys(+ input=self._first_present(candidates.input),+ output=self._first_present(candidates.output),+ tools=self._first_present(candidates.tools),+ )++ @property+ def error(self) -> str | None:+ value = self.row.properties.get("$ai_error")+ if not value:+ return FAILED_STEP_MESSAGE if read_flag(self.row.properties.get("$ai_is_error")) else None+ return value if isinstance(value, str) else json.dumps(value, indent=2, ensure_ascii=False)++ @property+ def metadata(self) -> NodeMetadata:+ properties = self.row.properties+ return NodeMetadata(+ provider=read_text(properties.get("$ai_provider")),+ temperature=read_number(properties.get("$ai_temperature")),+ session_id=read_text(properties.get("$ai_session_id")),+ prompt_name=read_text(properties.get("$ai_prompt_name")),+ prompt_version=read_number(properties.get("$ai_prompt_version")),+ )++ def _first_present(self, keys: tuple[str, ...]) -> str | None:+ return next((key for key in keys if self.row.properties.get(key) is not None), None)diff --git a/products/ai_observability/backend/logic/traces/trace.py b/products/ai_observability/backend/logic/traces/trace.pyindex 56d93f95ce1c..1d8e34535269 100644--- a/products/ai_observability/backend/logic/traces/trace.py+++ b/products/ai_observability/backend/logic/traces/trace.py@@ -66,6 +66,25 @@ class Trace:generation = pick_user_visible_generation(self.events)return [generation.id] if generation else []+ @cached_property+ def default_node_id(self) -> str:+ if any(event.is_trace_event for event in self.events):+ return self.id+ first_generation = next((node for node in self.tree if node.event.kind == "generation"), None)+ chosen = first_generation or next(iter(self.tree), None)+ return chosen.event.id if chosen else self.id++ @cached_property+ def node_ids_by_alias(self) -> dict[str, str]:+ aliases: dict[str, str] = {}+ for event in self.events:+ if event.is_annotation or event.is_trace_event:+ continue+ for alias in (event.row.generation_id, event.row.span_id):+ if alias and alias != event.id:+ aliases.setdefault(alias, event.id)+ return aliases+@propertydef person_label(self) -> str | None:if self.person is None or not self.person.distinct_id:diff --git a/products/ai_observability/backend/logic/traces/trace_queries.py b/products/ai_observability/backend/logic/traces/trace_queries.pyindex 2f8cecb510f2..e6e77c1dfe4b 100644--- a/products/ai_observability/backend/logic/traces/trace_queries.py+++ b/products/ai_observability/backend/logic/traces/trace_queries.py@@ -1,28 +1,32 @@import jsonimport math-from collections.abc import Sequence-from datetime import UTC, datetime, timedelta+from collections.abc import Callable, Sequence+from datetime import datetimefrom typing import Any+from uuid import UUIDimport structlogfrom posthog.hogql import ast+from posthog.hogql.context import HogQLContext+from posthog.hogql.database.database import Databasefrom posthog.hogql.query import execute_hogql_queryfrom posthog.clickhouse.query_tagging import Product, tag_queries, tags_contextfrom posthog.dataclasses import frozenfrom posthog.hogql_queries.ai.ai_table_resolver import query_ai_events+from posthog.hogql_queries.ai.utils import merge_heavy_propertiesfrom posthog.models import Team, User+from .events_fallback import FallbackWindow, events_filter, fallback_window, unhinted_windowfrom .person import trace_distinct_idTRACE_EVENT_NAMES = ("$ai_trace", "$ai_span", "$ai_generation", "$ai_embedding", "$ai_metric", "$ai_feedback")+NODE_EVENT_NAMES = ("$ai_span", "$ai_generation", "$ai_embedding")+_HEAVY_COLUMNS = ("input", "output", "output_choices", "input_state", "output_state", "tools")+_NODE_COLUMNS = ("uuid", "event", "timestamp", "properties", *_HEAVY_COLUMNS)# The largest result HogQL returns; without an explicit limit it returns 100 rows.MAX_TRACE_EVENTS = 50_000-FALLBACK_BEFORE_HINT = timedelta(minutes=10)-FALLBACK_AFTER_HINT = timedelta(days=7)-# The legacy trace view used this date as its default range start when a link carried no timestamp.-UNHINTED_FALLBACK_START = datetime(2025, 1, 10, tzinfo=UTC)TOKEN_PROPERTIES = {"input_tokens": "$ai_input_tokens","output_tokens": "$ai_output_tokens",@@ -65,12 +69,26 @@ class PersonRow:name: str | None+@frozen+class TraceNodeRow:+ uuid: str+ event: str+ timestamp: datetime+ properties: dict[str, Any]++@frozenclass LoadedTrace:rows: tuple[TraceEventRow, ...]person: PersonRow | None+@frozen+class TraceRootLookup:+ trace_event: TraceNodeRow | None+ trace_found: bool++def _raw_property(name: str) -> ast.Call:return ast.Call(name="JSONExtractRaw", args=[ast.Field(chain=["properties"]), ast.Constant(value=name)])@@ -126,26 +144,57 @@ def _ai_events() -> ast.JoinExpr:return ast.JoinExpr(table=ast.Field(chain=["posthog", "ai_events"]), alias="ai_events")+def _event_in(names: Sequence[str]) -> ast.Expr:+ return ast.CompareOperation(+ op=ast.CompareOperationOp.In,+ left=ast.Field(chain=["event"]),+ right=ast.Tuple(exprs=[ast.Constant(value=name) for name in names]),+ )+++def _equals(column: str, value: str) -> ast.Expr:+ return ast.CompareOperation(+ op=ast.CompareOperationOp.Eq, left=ast.Field(chain=[column]), right=ast.Constant(value=value)+ )+++def _filter_conditions() -> ast.Placeholder:+ return ast.Placeholder(expr=ast.Field(chain=["filter_conditions"]))++def _trace_rows_query() -> ast.SelectQuery:return ast.SelectQuery(select=_select(),select_from=_ai_events(),- where=ast.And(- exprs=[- ast.CompareOperation(- op=ast.CompareOperationOp.In,- left=ast.Field(chain=["event"]),- right=ast.Tuple(exprs=[ast.Constant(value=name) for name in TRACE_EVENT_NAMES]),- ),- ast.Placeholder(expr=ast.Field(chain=["filter_conditions"])),- ]- ),+ where=ast.And(exprs=[_event_in(TRACE_EVENT_NAMES), _filter_conditions()]),order_by=[ast.OrderExpr(expr=ast.Field(chain=["timestamp"]), order="ASC")],limit_by=ast.LimitByExpr(n=ast.Constant(value=1), exprs=[ast.Field(chain=["uuid"])]),limit=ast.Constant(value=MAX_TRACE_EVENTS),)+def _node_query(selection: ast.Expr) -> ast.SelectQuery:+ return ast.SelectQuery(+ select=[ast.Field(chain=[column]) for column in _NODE_COLUMNS],+ select_from=_ai_events(),+ where=ast.And(exprs=[selection, _filter_conditions()]),+ limit=ast.Constant(value=1),+ )+++def _node_selection(node_id: str) -> ast.Expr:+ return ast.And(exprs=[_event_in(NODE_EVENT_NAMES), _equals("uuid", node_id)])+++def _trace_exists_query() -> ast.SelectQuery:+ return ast.SelectQuery(+ select=[ast.Field(chain=["uuid"])],+ select_from=_ai_events(),+ where=ast.And(exprs=[_event_in(TRACE_EVENT_NAMES), _filter_conditions()]),+ limit=ast.Constant(value=1),+ )++def _person_query(distinct_id: str) -> ast.SelectQuery:def latest(column: str) -> ast.Call:return ast.Call(name="argMax", args=[ast.Field(chain=[column]), ast.Field(chain=["version"])])@@ -172,41 +221,7 @@ def _person_query(distinct_id: str) -> ast.SelectQuery:def _trace_filter(trace_id: str) -> ast.Expr:- return ast.CompareOperation(- op=ast.CompareOperationOp.Eq, left=ast.Field(chain=["trace_id"]), right=ast.Constant(value=trace_id)- )---@frozen-class FallbackWindow:- start: datetime- end: datetime---def fallback_window(timestamp_hint: datetime) -> FallbackWindow:- """Raises OverflowError when the window around the hint leaves the datetime range."""- return FallbackWindow(start=timestamp_hint - FALLBACK_BEFORE_HINT, end=timestamp_hint + FALLBACK_AFTER_HINT)---def _fallback_filter(trace_id: str, window: FallbackWindow | None) -> ast.Expr:- if window is None:- # The shared events table is not sorted by trace id, so a read without a window must not scan it.- return ast.Constant(value=False)- return ast.And(- exprs=[- _trace_filter(trace_id),- ast.CompareOperation(- op=ast.CompareOperationOp.GtEq,- left=ast.Field(chain=["timestamp"]),- right=ast.Constant(value=window.start),- ),- ast.CompareOperation(- op=ast.CompareOperationOp.LtEq,- left=ast.Field(chain=["timestamp"]),- right=ast.Constant(value=window.end),- ),- ]- )+ return _equals("trace_id", trace_id)def _read(@@ -225,22 +240,27 @@ def _read(user=user,query_type=name,fall_back_to_events=True,- fallback_placeholders={"filter_conditions": _fallback_filter(trace_id, window)},+ fallback_placeholders={+ "filter_conditions": events_filter(+ trace_filter=_trace_filter(trace_id), event_filter=_event_in(TRACE_EVENT_NAMES), window=window+ )+ },+ posthog_tables_only=True,)return list(response.results or [])-def _text(value: Any) -> str | None:+def read_text(value: Any) -> str | None:return value if isinstance(value, str) and value else None-def _flag(value: Any) -> bool:+def read_flag(value: Any) -> bool:if isinstance(value, str):return value.strip().lower() in ("true", "1")return value is True or value == 1-def _number(value: Any) -> float | None:+def read_number(value: Any) -> float | None:# The events fallback reads untyped properties, so a count or cost can arrive as any string.if value is None or isinstance(value, bool):return None@@ -252,7 +272,7 @@ def _number(value: Any) -> float | None:def _count(value: Any) -> int | None:- number = _number(value)+ number = read_number(value)return None if number is None else int(number)@@ -288,20 +308,20 @@ def _trace_event_row(values: Sequence[Any]) -> TraceEventRow:event=str(raw["event"]),timestamp=raw["timestamp"],distinct_id=str(raw["distinct_id"]),- session_id=_text(raw["session_id"]),- parent_id=_text(raw["parent_id"]),- span_id=_text(raw["span_id"]),- generation_id=_text(raw["generation_id"]),- span_name=_text(raw["span_name"]),- trace_name=_text(raw["trace_name"]),- model=_text(raw["model"]),- provider=_text(raw["provider"]),+ session_id=read_text(raw["session_id"]),+ parent_id=read_text(raw["parent_id"]),+ span_id=read_text(raw["span_id"]),+ generation_id=read_text(raw["generation_id"]),+ span_name=read_text(raw["span_name"]),+ trace_name=read_text(raw["trace_name"]),+ model=read_text(raw["model"]),+ provider=read_text(raw["provider"]),**tokens,- total_cost_usd=_number(raw["total_cost_usd"]),- latency=_number(raw["latency"]),- is_error=_flag(raw["is_error"]),+ total_cost_usd=read_number(raw["total_cost_usd"]),+ latency=read_number(raw["latency"]),+ is_error=read_flag(raw["is_error"]),error_is_truthy=is_truthy_json(raw["error_raw"]),- ingestion_source=_text(raw["ingestion_source"]),+ ingestion_source=read_text(raw["ingestion_source"]),)@@ -309,27 +329,92 @@ def _read_person(team: Team, user: User | None, distinct_id: str) -> PersonRow:name = "ai_trace_person"with tags_context(product=Product.LLM_ANALYTICS):tag_queries(name=name)- response = execute_hogql_query(query=_person_query(distinct_id), team=team, user=user, query_type=name)+ response = execute_hogql_query(+ query=_person_query(distinct_id),+ team=team,+ user=user,+ query_type=name,+ context=HogQLContext(+ team_id=team.pk, team=team, user=user, database=Database.create_for_posthog_tables(team)+ ),+ )email, person_name = response.results[0] if response.results else (None, None)- return PersonRow(distinct_id=distinct_id, email=_text(email), name=_text(person_name))+ return PersonRow(distinct_id=distinct_id, email=read_text(email), name=read_text(person_name))-def _read_rows(team: Team, user: User | None, trace_id: str, timestamp_hint: datetime | None) -> list[Sequence[Any]]:- name = "ai_trace_rows"+def _read_trace(+ name: str,+ build_query: Callable[[], ast.SelectQuery],+ team: Team,+ user: User | None,+ trace_id: str,+ timestamp_hint: datetime | None,+ *,+ widen_unhinted: bool,+) -> list[Sequence[Any]]:if timestamp_hint is not None:- return _read(name, _trace_rows_query(), team, user, trace_id, fallback_window(timestamp_hint))- results = _read(name, _trace_rows_query(), team, user, trace_id, None)- if results:+ return _read(name, build_query(), team, user, trace_id, fallback_window(timestamp_hint))+ results = _read(name, build_query(), team, user, trace_id, None)+ if results or not widen_unhinted:return results- logger.warning("ai_trace_unhinted_events_fallback", team_id=team.pk, trace_id_length=len(trace_id))- window = FallbackWindow(- start=UNHINTED_FALLBACK_START - FALLBACK_BEFORE_HINT, end=datetime.now(UTC) + FALLBACK_AFTER_HINT- )- return _read(name, _trace_rows_query(), team, user, trace_id, window)+ logger.warning("ai_trace_unhinted_events_fallback", team_id=team.pk, trace_id_length=len(trace_id), read=name)+ return _read(name, build_query(), team, user, trace_id, unhinted_window())def load_trace(team: Team, user: User | None, trace_id: str, timestamp_hint: datetime | None) -> LoadedTrace:- rows = tuple(_trace_event_row(values) for values in _read_rows(team, user, trace_id, timestamp_hint))+ rows = tuple(+ _trace_event_row(values)+ for values in _read_trace(+ "ai_trace_rows", _trace_rows_query, team, user, trace_id, timestamp_hint, widen_unhinted=True+ )+ )distinct_id = trace_distinct_id(rows)person = _read_person(team, user, distinct_id) if distinct_id else Nonereturn LoadedTrace(rows=rows, person=person)+++def _canonical_uuid(value: str) -> str | None:+ try:+ return str(UUID(value))+ except ValueError:+ return None+++def _trace_node_row(values: Sequence[Any]) -> TraceNodeRow:+ raw = dict(zip(_NODE_COLUMNS, values))+ return TraceNodeRow(+ uuid=str(raw["uuid"]),+ event=str(raw["event"]),+ timestamp=raw["timestamp"],+ properties=merge_heavy_properties(raw["properties"], {column: raw[column] for column in _HEAVY_COLUMNS}),+ )+++# Node ids come from links and can be stale or SDK ids, so node reads never widen to the unhinted events scan.+def load_trace_node(+ team: Team, user: User | None, trace_id: str, node_id: str, timestamp_hint: datetime | None+) -> TraceNodeRow | None:+ event_uuid = _canonical_uuid(node_id)+ if event_uuid is None:+ return None+ results = _read_trace(+ "ai_trace_node",+ lambda: _node_query(_node_selection(event_uuid)),+ team,+ user,+ trace_id,+ timestamp_hint,+ widen_unhinted=False,+ )+ return _trace_node_row(results[0]) if results else None+++def load_trace_root(team: Team, user: User | None, trace_id: str, timestamp_hint: datetime | None) -> TraceRootLookup:+ def read(name: str, build_query: Callable[[], ast.SelectQuery]) -> list[Sequence[Any]]:+ return _read_trace(name, build_query, team, user, trace_id, timestamp_hint, widen_unhinted=False)++ results = read("ai_trace_root", lambda: _node_query(_equals("event", "$ai_trace")))+ if results:+ return TraceRootLookup(trace_event=_trace_node_row(results[0]), trace_found=True)+ # Most traces have no $ai_trace event, so the existence check reads light columns instead of a step's payload.+ return TraceRootLookup(trace_event=None, trace_found=bool(read("ai_trace_exists", _trace_exists_query)))diff --git a/products/ai_observability/backend/presentation/views.py b/products/ai_observability/backend/presentation/views.pyindex a815df813550..2d0dcd3f9129 100644--- a/products/ai_observability/backend/presentation/views.py+++ b/products/ai_observability/backend/presentation/views.py@@ -1,9 +1,11 @@+from collections.abc import Callablefrom datetime import datetimefrom typing import Anyfrom drf_spectacular.types import OpenApiTypesfrom drf_spectacular.utils import OpenApiParameter, OpenApiResponsefrom rest_framework import serializers, status, viewsets+from rest_framework.decorators import actionfrom rest_framework.response import Responsefrom posthog.api.documentation import _FallbackSerializer@@ -29,27 +31,42 @@ class TraceQuerySerializer(serializers.Serializer):return value+TRACE_ID_PARAMETER = OpenApiParameter(+ "id",+ OpenApiTypes.STR,+ OpenApiParameter.PATH,+ description="The trace id, sent as the unpadded base64url encoding of its UTF-8 bytes.",+)+NODE_ID_PARAMETER = OpenApiParameter(+ "node_id",+ OpenApiTypes.STR,+ OpenApiParameter.PATH,+ description="The node id, sent as the unpadded base64url encoding of its UTF-8 bytes. The root node's id is the trace id.",+)+THROTTLED_RESPONSE = OpenApiResponse(description="Too many queries are running for the project or organization.")++class TraceViewSet(TeamAndOrgViewSetMixin, viewsets.ViewSet):scope_object = "llm_analytics"+ scope_object_read_actions = ["retrieve", "node"]# Traces are project-wide data, so a grant on a single llm_analytics object must not open them.requires_resource_level_access = Trueserializer_class = _FallbackSerializer+ def _read[T](self, request: ValidatedRequest, read: Callable[[User | None, datetime | None], T]) -> T:+ tag_queries(feature=Feature.QUERY)+ user = request.user if isinstance(request.user, User) else None+ with query_concurrency_slots(self.team):+ return read(user, request.validated_query_data.get("timestamp_hint"))+@validated_request(query_serializer=TraceQuerySerializer,- parameters=[- OpenApiParameter(- "id",- OpenApiTypes.STR,- OpenApiParameter.PATH,- description="The trace id, sent as the unpadded base64url encoding of its UTF-8 bytes.",- )- ],+ parameters=[TRACE_ID_PARAMETER],responses={200: OpenApiResponse(response=contracts.Trace),400: OpenApiResponse(description="The timestamp hint or the encoded trace id is malformed."),404: OpenApiResponse(description="No trace with this id in the project."),- 429: OpenApiResponse(description="Too many queries are running for the project or organization."),+ 429: THROTTLED_RESPONSE,},operation_id="ai_observability_traces_retrieve",)@@ -59,11 +76,35 @@ class TraceViewSet(TeamAndOrgViewSetMixin, viewsets.ViewSet):trace_id = decode_trace_id_segment(pk)except MalformedTraceIdSegmentError:return Response({"detail": "Malformed encoded trace id."}, status=status.HTTP_400_BAD_REQUEST)- tag_queries(feature=Feature.QUERY)- user = request.user if isinstance(request.user, User) else Nonetry:- with query_concurrency_slots(self.team):- trace = api.get_trace(self.team, user, trace_id, request.validated_query_data.get("timestamp_hint"))+ trace = self._read(request, lambda user, hint: api.get_trace(self.team, user, trace_id, hint))except api.TraceNotFoundError:return Response({"detail": "Trace not found."}, status=status.HTTP_404_NOT_FOUND)return Response(trace.model_dump(mode="json", by_alias=True))++ @validated_request(+ query_serializer=TraceQuerySerializer,+ parameters=[TRACE_ID_PARAMETER, NODE_ID_PARAMETER],+ responses={+ 200: OpenApiResponse(response=contracts.TraceNodeDetail),+ 400: OpenApiResponse(description="The timestamp hint or an encoded id is malformed."),+ 404: OpenApiResponse(description="No node with this id in the trace."),+ 429: THROTTLED_RESPONSE,+ },+ operation_id="ai_observability_traces_nodes_retrieve",+ )+ @action(detail=True, methods=["GET"], url_path=r"nodes/(?P<node_id>[A-Za-z0-9_-]+)")+ def node(self, request: ValidatedRequest, pk: str, node_id: str, **kwargs: Any) -> Response:+ """One node of a trace: its event properties as ingested, the keys that hold its input, output and tools, its error and its metadata."""+ try:+ trace_id = decode_trace_id_segment(pk)+ decoded_node_id = decode_trace_id_segment(node_id)+ except MalformedTraceIdSegmentError:+ return Response({"detail": "Malformed encoded id."}, status=status.HTTP_400_BAD_REQUEST)+ try:+ node = self._read(+ request, lambda user, hint: api.get_trace_node(self.team, user, trace_id, decoded_node_id, hint)+ )+ except api.TraceNodeNotFoundError:+ return Response({"detail": "Node not found."}, status=status.HTTP_404_NOT_FOUND)+ return Response(node.model_dump(mode="json", by_alias=True))diff --git a/products/ai_observability/backend/tests/logic/traces/test_node.py b/products/ai_observability/backend/tests/logic/traces/test_node.pynew file mode 100644index 000000000000..1bb770120bea--- /dev/null+++ b/products/ai_observability/backend/tests/logic/traces/test_node.py@@ -0,0 +1,124 @@+import json+from datetime import UTC, datetime+from typing import Any++from parameterized import parameterized++from products.ai_observability.backend.logic.traces.node import FAILED_STEP_MESSAGE, IOKeys, NodeEvent, NodeMetadata+from products.ai_observability.backend.logic.traces.trace_queries import TraceNodeRow++T0 = datetime(2026, 9, 1, 10, 0, tzinfo=UTC)+MESSAGES = [{"role": "user", "content": "Why did my invoice go up?"}]+NO_METADATA = NodeMetadata(provider=None, temperature=None, session_id=None, prompt_name=None, prompt_version=None)+++def node_event(event: str, properties: dict[str, Any]) -> NodeEvent:+ return NodeEvent(row=TraceNodeRow(uuid="node-1", event=event, timestamp=T0, properties=properties))+++ [+ (+ "generation",+ "$ai_generation",+ {"$ai_input": MESSAGES, "$ai_output_choices": MESSAGES, "$ai_tools": []},+ IOKeys(input="$ai_input", output="$ai_output_choices", tools="$ai_tools"),+ ),+ (+ "generation with a plain output",+ "$ai_generation",+ {"$ai_input": MESSAGES, "$ai_output": "Two seats were added."},+ IOKeys(input="$ai_input", output="$ai_output", tools=None),+ ),+ (+ "generation whose output choices are null",+ "$ai_generation",+ {"$ai_output_choices": None, "$ai_output": "Two seats were added."},+ IOKeys(input=None, output="$ai_output", tools=None),+ ),+ ("generation with nothing captured", "$ai_generation", {}, IOKeys(input=None, output=None, tools=None)),+ (+ "embedding never has an output",+ "$ai_embedding",+ {"$ai_input": "invoice", "$ai_output": [0.1, 0.2]},+ IOKeys(input="$ai_input", output=None, tools=None),+ ),+ (+ "span state",+ "$ai_span",+ {"$ai_input_state": {"question": "x"}, "$ai_output_state": {"answer": "y"}},+ IOKeys(input="$ai_input_state", output="$ai_output_state", tools=None),+ ),+ (+ "OTel span with messages before its state",+ "$ai_span",+ {"$ai_input": MESSAGES, "$ai_output_choices": MESSAGES, "$ai_input_state": {"question": "x"}},+ IOKeys(input="$ai_input", output="$ai_output_choices", tools=None),+ ),+ ("span never has tools", "$ai_span", {"$ai_tools": []}, IOKeys(input=None, output=None, tools=None)),+ (+ "trace event state",+ "$ai_trace",+ {"$ai_input_state": {"question": "x"}, "$ai_output_state": {"answer": "y"}},+ IOKeys(input="$ai_input_state", output="$ai_output_state", tools=None),+ ),+ (+ "trace event with messages and state prefers the state",+ "$ai_trace",+ {+ "$ai_input": MESSAGES,+ "$ai_input_state": {"question": "x"},+ "$ai_output_choices": MESSAGES,+ "$ai_output_state": {"answer": "y"},+ },+ IOKeys(input="$ai_input_state", output="$ai_output_state", tools=None),+ ),+ ]+)+def test_io_keys(_name: str, event: str, properties: dict[str, Any], expected: IOKeys) -> None:+ assert node_event(event, properties).io_keys == expected+++ [+ ("text error", {"$ai_error": "Rate limited"}, "Rate limited"),+ ("structured error", {"$ai_error": {"message": "boom"}}, json.dumps({"message": "boom"}, indent=2)),+ ("flag without a message", {"$ai_is_error": True}, FAILED_STEP_MESSAGE),+ ("SDK-serialized flag with an empty message", {"$ai_is_error": "true", "$ai_error": ""}, FAILED_STEP_MESSAGE),+ ("empty message without a flag", {"$ai_error": ""}, None),+ ("flag off", {"$ai_is_error": False}, None),+ ]+)+def test_error(_name: str, properties: dict[str, Any], expected: str | None) -> None:+ assert node_event("$ai_span", properties).error == expected+++ [+ (+ "values as sent",+ {+ "$ai_provider": "openai",+ "$ai_temperature": 0.2,+ "$ai_session_id": "sess-1",+ "$ai_prompt_name": "billing-answer",+ "$ai_prompt_version": 6,+ },+ NodeMetadata(+ provider="openai",+ temperature=0.2,+ session_id="sess-1",+ prompt_name="billing-answer",+ prompt_version=6.0,+ ),+ ),+ (+ "numbers sent as text and empty text",+ {"$ai_temperature": "0.2", "$ai_session_id": "", "$ai_prompt_version": "6"},+ NodeMetadata(provider=None, temperature=0.2, session_id=None, prompt_name=None, prompt_version=6.0),+ ),+ ("values that are not numbers", {"$ai_temperature": "warm", "$ai_prompt_version": float("inf")}, NO_METADATA),+ ]+)+def test_metadata(_name: str, properties: dict[str, Any], expected: NodeMetadata) -> None:+ assert node_event("$ai_generation", properties).metadata == expecteddiff --git a/products/ai_observability/backend/tests/logic/traces/test_trace.py b/products/ai_observability/backend/tests/logic/traces/test_trace.pyindex 1e80bb260171..d84faca6c538 100644--- a/products/ai_observability/backend/tests/logic/traces/test_trace.py+++ b/products/ai_observability/backend/tests/logic/traces/test_trace.py@@ -89,3 +89,47 @@ def test_thread_node_ids_hold_the_user_visible_generation() -> None:)def test_person_label(_name: str, person: PersonRow | None, expected: str | None) -> None:assert trace({}, person=person).person_label == expected+++ [+ (+ "a trace event makes the root the default",+ [{"event": "$ai_trace"}, {"event": "$ai_generation"}],+ "trace-1",+ ),+ (+ "otherwise the first top-level generation",+ [+ {"event": "$ai_span", "timestamp": T0},+ {"event": "$ai_generation", "timestamp": T0 + timedelta(seconds=1)},+ {"event": "$ai_generation", "timestamp": T0 + timedelta(seconds=2)},+ ],+ "e1",+ ),+ (+ "otherwise the first top-level node",+ [+ {"event": "$ai_span", "span_id": "s", "timestamp": T0},+ {"event": "$ai_generation", "parent_id": "s", "timestamp": T0 + timedelta(seconds=1)},+ ],+ "e0",+ ),+ ("a trace without nodes falls back to the root", [{"event": "$ai_feedback"}], "trace-1"),+ ]+)+def test_default_node_id(_name: str, rows: list[dict[str, Any]], expected: str) -> None:+ assert trace(*rows).default_node_id == expected+++def test_node_ids_by_alias_map_sdk_ids_of_tree_nodes_to_their_uuids() -> None:+ aliases = trace(+ {"event": "$ai_span", "span_id": "span-a"},+ {"event": "$ai_generation", "generation_id": "gen-a", "parent_id": "span-a"},+ {"event": "$ai_generation", "generation_id": "gen-a"},+ {"event": "$ai_span", "span_id": "e3"},+ {"event": "$ai_feedback", "span_id": "feedback-a"},+ {"event": "$ai_trace", "span_id": "trace-a"},+ ).node_ids_by_alias++ assert aliases == {"span-a": "e0", "gen-a": "e1"}diff --git a/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py b/products/ai_observability/backend/tests/logic/traces/test_trace_queries.pyindex 77c79623499c..aa133f67436a 100644--- a/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py+++ b/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py@@ -6,11 +6,18 @@ from posthog.test.base import BaseTest, ClickhouseTestMixin, _create_personfrom parameterized import parameterizedfrom posthog.clickhouse.client import sync_execute+from posthog.models import Teamfrom posthog.models.ai_events.sql import AI_EVENTS_MV_SQLfrom posthog.models.ai_events.test_util import bulk_create_ai_eventsfrom posthog.models.event.util import bulk_create_events-from products.ai_observability.backend.logic.traces.trace_queries import is_truthy_json, load_trace+from products.ai_observability.backend.logic.traces.trace_queries import (+ TraceRootLookup,+ is_truthy_json,+ load_trace,+ load_trace_node,+ load_trace_root,+)T0 = datetime(2026, 9, 1, 10, 0, tzinfo=UTC)INGESTED_SOURCE = """(@@ -49,7 +56,9 @@ def test_is_truthy_json(_name: str, raw: str, expected: bool) -> None:assert is_truthy_json(raw) is expected-class TestLoadTrace(ClickhouseTestMixin, BaseTest):+class TraceEventsMixin:+ team: Team+def _event(self,uuid: str,@@ -68,12 +77,12 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):"properties": {"$ai_trace_id": trace_id, **(properties or {})},}- def _ingest(self, uuid: str, properties: dict[str, object]) -> None:+ def _ingest(self, uuid: str, properties: dict[str, object], *, event: str = "$ai_span") -> None:# Goes through the materialized view expressions, because bulk_create_ai_events types columns differently.mv_select = AI_EVENTS_MV_SQL(kafka_table=INGESTED_SOURCE).split("AS SELECT", 1)[1]params = {"uuid": uuid,- "event": "$ai_span",+ "event": event,"timestamp": T0.strftime("%Y-%m-%d %H:%M:%S.%f"),"team_id": self.team.pk,"properties": json.dumps({"$ai_trace_id": "trace-1", **properties}),@@ -85,6 +94,8 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):flush=False,)++class TestLoadTrace(TraceEventsMixin, ClickhouseTestMixin, BaseTest):def test_reads_every_event_once_and_only_this_trace(self) -> None:uuids = [f"00000000-0000-0000-0000-{index:012d}" for index in range(150)]failed = self._event(uuids[0], properties={"$ai_latency": 1.0, "$ai_error": {"message": "boom"}})@@ -110,6 +121,92 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):("00000000-0000-0000-0000-000000000002", True, 3),]+ def test_person_comes_from_the_trace_event_distinct_id(self) -> None:+ _create_person(distinct_ids=["user-1"], team=self.team, properties={"email": "[email protected]"})+ _create_person(distinct_ids=["user-2"], team=self.team, properties={"email": "[email protected]"})+ earlier_span = {**self._event("00000000-0000-0000-0000-000000000002"), "distinct_id": "user-2"}+ trace_event = self._event(+ "00000000-0000-0000-0000-000000000001", event="$ai_trace", timestamp=T0 + timedelta(seconds=1)+ )+ bulk_create_ai_events([earlier_span, trace_event])++ person = load_trace(self.team, None, "trace-1", None).person++ assert person is not None and (person.distinct_id, person.email) == ("user-1", "[email protected]")+++NODE = "00000000-0000-0000-0000-000000000001"+TRACE_EVENT = "00000000-0000-0000-0000-000000000002"+QUESTION = [{"role": "user", "content": "Why did my invoice go up?"}]+ANSWER = [{"role": "assistant", "content": "Two seats were added."}]+++class TestLoadTraceNode(TraceEventsMixin, ClickhouseTestMixin, BaseTest):+ def test_merges_the_heavy_columns_back_into_the_properties(self) -> None:+ self._ingest(+ NODE,+ {"$ai_input": QUESTION, "$ai_output_choices": ANSWER, "$ai_model": "gpt-4.1-mini"},+ event="$ai_generation",+ )++ row = load_trace_node(self.team, None, "trace-1", NODE, None)++ assert row is not None+ assert (row.uuid, row.event) == (NODE, "$ai_generation")+ assert (row.properties["$ai_input"], row.properties["$ai_output_choices"]) == (QUESTION, ANSWER)+ assert row.properties["$ai_model"] == "gpt-4.1-mini"++ @parameterized.expand(+ [+ ("an annotation", "$ai_feedback", "trace-1", NODE),+ ("a node of another trace", "$ai_span", "other", NODE),+ ("an id that is not an event uuid", "$ai_span", "trace-1", "gen_8f2c"),+ ]+ )+ def test_finds_nothing_for(self, _name: str, event: str, trace_id: str, requested: str) -> None:+ bulk_create_ai_events([self._event(NODE, trace_id=trace_id, event=event)])++ assert load_trace_node(self.team, None, "trace-1", requested, None) is None++ def test_root_reads_the_trace_event_even_when_other_events_come_first(self) -> None:+ bulk_create_ai_events(+ [+ self._event(NODE, timestamp=T0),+ self._event(+ TRACE_EVENT,+ event="$ai_trace",+ timestamp=T0 + timedelta(seconds=5),+ properties={"$ai_input_state": {"question": "x"}},+ ),+ ]+ )++ root = load_trace_root(self.team, None, "trace-1", None)++ assert root.trace_found and root.trace_event is not None+ assert (root.trace_event.uuid, root.trace_event.properties["$ai_input_state"]) == (+ TRACE_EVENT,+ {"question": "x"},+ )++ @parameterized.expand([("a trace without a trace event", True), ("an unknown trace", False)])+ def test_root_without_a_trace_event(self, _name: str, has_events: bool) -> None:+ if has_events:+ bulk_create_ai_events([self._event(NODE)])++ assert load_trace_root(self.team, None, "trace-1", None) == TraceRootLookup(+ trace_event=None, trace_found=has_events+ )++ def test_node_id_matches_however_the_uuid_is_written(self) -> None:+ bulk_create_ai_events([self._event(NODE)])++ row = load_trace_node(self.team, None, "trace-1", NODE.upper().replace("-", ""), None)++ assert row is not None and row.uuid == NODE+++class TestEventsFallback(TraceEventsMixin, ClickhouseTestMixin, BaseTest):@parameterized.expand([("with a hint", T0), ("without a hint", None)])def test_falls_back_to_events(self, _name: str, timestamp_hint: datetime | None) -> None:old_span: dict[str, object] = {"$ai_span_name": "old", "$ai_error": {"message": "boom"}}@@ -140,15 +237,22 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):assert load_trace(self.team, None, "trace-1", None).rows == ()- def test_person_comes_from_the_trace_event_distinct_id(self) -> None:- _create_person(distinct_ids=["user-1"], team=self.team, properties={"email": "[email protected]"})- _create_person(distinct_ids=["user-2"], team=self.team, properties={"email": "[email protected]"})- earlier_span = {**self._event("00000000-0000-0000-0000-000000000002"), "distinct_id": "user-2"}- trace_event = self._event(- "00000000-0000-0000-0000-000000000001", event="$ai_trace", timestamp=T0 + timedelta(seconds=1)+ def test_node_and_root_fall_back_to_events(self) -> None:+ bulk_create_events(+ [+ self._event(NODE, properties={"$ai_span_name": "old"}),+ self._event(TRACE_EVENT, event="$ai_trace", timestamp=T0 + timedelta(seconds=1)),+ ])- bulk_create_ai_events([earlier_span, trace_event])- person = load_trace(self.team, None, "trace-1", None).person+ row = load_trace_node(self.team, None, "trace-1", NODE, T0)+ root = load_trace_root(self.team, None, "trace-1", T0)- assert person is not None and (person.distinct_id, person.email) == ("user-1", "[email protected]")+ assert row is not None and row.properties["$ai_span_name"] == "old"+ assert root.trace_event is not None and root.trace_event.uuid == TRACE_EVENT++ def test_node_and_root_without_a_hint_never_scan_events(self) -> None:+ bulk_create_events([self._event(NODE), self._event(TRACE_EVENT, event="$ai_trace")])++ assert load_trace_node(self.team, None, "trace-1", NODE, None) is None+ assert load_trace_root(self.team, None, "trace-1", None) == TraceRootLookup(trace_event=None, trace_found=False)diff --git a/products/ai_observability/backend/tests/test_contracts.py b/products/ai_observability/backend/tests/test_contracts.pyindex db1989c3efbb..f7a8499904ef 100644--- a/products/ai_observability/backend/tests/test_contracts.py+++ b/products/ai_observability/backend/tests/test_contracts.py@@ -29,6 +29,8 @@ def test_trace_dumps_declared_fields_in_camel_case_and_every_field_is_required_itimeline=[],total_ms=0.0,thread_node_ids=[],+ default_node_id="trace-1",+ node_ids_by_alias={},)dumped = trace.model_dump(mode="json", by_alias=True)@@ -46,6 +48,8 @@ def test_trace_dumps_declared_fields_in_camel_case_and_every_field_is_required_i"timeline","totalMs","threadNodeIds",+ "defaultNodeId",+ "nodeIdsByAlias",}assert dumped["totals"]["cacheWriteTokens"] is Noneassert dumped["person"] == {"distinctId": "user-1", "label": "[email protected]"}diff --git a/products/ai_observability/backend/tests/test_trace_views.py b/products/ai_observability/backend/tests/test_trace_views.pyindex 12e6be4d726a..0a5bf3c091a7 100644--- a/products/ai_observability/backend/tests/test_trace_views.py+++ b/products/ai_observability/backend/tests/test_trace_views.py@@ -13,10 +13,17 @@ from posthog.models.ai_events.test_util import bulk_create_ai_eventsfrom posthog.models.organization import OrganizationMembershipfrom posthog.models.user import User+from products.access_control.backend.facade.contracts import PropertyAccessLevelfrom products.access_control.backend.models.access_control import AccessControl+from products.access_control.backend.models.property_access_control import PropertyAccessControlfrom products.ai_observability.backend.models.review_queues import ReviewQueue+from products.event_definitions.backend.models.property_definition import PropertyDefinitionT0 = datetime(2026, 9, 1, 10, 0, tzinfo=UTC)+GENERATION = "00000000-0000-0000-0000-000000000001"+TRACE_EVENT = "00000000-0000-0000-0000-000000000002"+QUESTION = [{"role": "user", "content": "Why did my invoice go up?"}]+ANSWER = [{"role": "assistant", "content": "Two seats were added."}]def _create_trace(team: Team, trace_id: str = "trace-1") -> None:@@ -34,6 +41,45 @@ def _create_trace(team: Team, trace_id: str = "trace-1") -> None:)+def _create_node_trace(+ team: Team,+ trace_id: str = "trace-1",+ *,+ with_trace_event: bool = True,+ extra_properties: dict[str, object] | None = None,+) -> None:+ events: list[dict[str, object]] = [+ {+ "event": "$ai_generation",+ "event_uuid": GENERATION,+ "distinct_id": "user-1",+ "team": team,+ "timestamp": T0,+ "properties": {+ "$ai_trace_id": trace_id,+ "$ai_parent_id": trace_id,+ "$ai_input": QUESTION,+ "$ai_output_choices": ANSWER,+ "$ai_tools": [{"name": "lookup_invoice"}],+ "$ai_provider": "openai",+ **(extra_properties or {}),+ },+ }+ ]+ if with_trace_event:+ events.append(+ {+ "event": "$ai_trace",+ "event_uuid": TRACE_EVENT,+ "distinct_id": "user-1",+ "team": team,+ "timestamp": T0,+ "properties": {"$ai_trace_id": trace_id, "$ai_input_state": {"question": "Why?"}},+ }+ )+ bulk_create_ai_events(events)++def _encode(trace_id: str) -> str:return base64.urlsafe_b64encode(trace_id.encode()).decode().rstrip("=")@@ -54,6 +100,8 @@ class TestTraceViewSet(ClickhouseTestMixin, APIBaseTest):assert body["tree"][0]["children"][0]["id"] == "00000000-0000-0000-0000-000000000001"assert body["totals"]["inputTokens"] == 3assert body["threadNodeIds"] == ["00000000-0000-0000-0000-000000000001"]+ assert body["defaultNodeId"] == "00000000-0000-0000-0000-000000000001"+ assert body["nodeIdsByAlias"] == {}@parameterized.expand([("unknown trace", False), ("another team's trace", True)])def test_not_found(self, _name: str, other_team_owns_it: bool) -> None:@@ -75,9 +123,18 @@ class TestTraceViewSet(ClickhouseTestMixin, APIBaseTest):assert self.client.get(self._url(segment), query).status_code == 400- @parameterized.expand([("browser session", False, "app_per_org"), ("personal api key", True, "api_per_team")])+ @parameterized.expand(+ [+ (f"{reader} {read}", with_api_key, exhausted_limit, suffix)+ for reader, with_api_key, exhausted_limit in [+ ("browser session", False, "app_per_org"),+ ("personal api key", True, "api_per_team"),+ ]+ for read, suffix in [("trace", ""), ("node", f"nodes/{_encode('trace-1')}/")]+ ]+ )def test_throttles_when_the_query_concurrency_limit_is_exhausted(- self, _name: str, with_api_key: bool, exhausted_limit: str+ self, _name: str, with_api_key: bool, exhausted_limit: str, suffix: str) -> None:_create_trace(self.team, "trace-1")headers = {}@@ -94,11 +151,90 @@ class TestTraceViewSet(ClickhouseTestMixin, APIBaseTest):patch("posthog.clickhouse.client.limit.TEST", False),patch.object(RateLimit, "use", autospec=True, side_effect=use),):- response = self.client.get(self._url(_encode("trace-1")), headers=headers)+ response = self.client.get(self._url(_encode("trace-1")) + suffix, headers=headers)assert response.status_code == 429+class TestTraceNodeView(ClickhouseTestMixin, APIBaseTest):+ def _url(self, trace_id: str, node_segment: str) -> str:+ return f"/api/projects/{self.team.id}/ai_observability/traces/{_encode(trace_id)}/nodes/{node_segment}/"++ def test_returns_the_properties_as_ingested_and_names_the_io_keys(self) -> None:+ _create_node_trace(self.team)++ response = self.client.get(self._url("trace-1", _encode(GENERATION)))++ assert response.status_code == 200, response.content+ body = response.json()+ assert (body["id"], body["kind"], body["error"]) == (GENERATION, "generation", None)+ assert body["metadata"]["provider"] == "openai"+ assert body["event"]["ioKeys"] == {"input": "$ai_input", "output": "$ai_output_choices", "tools": "$ai_tools"}+ assert body["event"]["properties"]["$ai_input"] == QUESTION++ @parameterized.expand([("plain id", "trace-1"), ("id with a slash", "a/b")])+ def test_root_node_is_the_trace_event(self, _name: str, trace_id: str) -> None:+ _create_node_trace(self.team, trace_id)++ body = self.client.get(self._url(trace_id, _encode(trace_id))).json()++ assert (body["id"], body["kind"]) == (trace_id, "trace")+ assert body["event"]["ioKeys"]["input"] == "$ai_input_state"++ def test_root_without_a_trace_event_has_no_event(self) -> None:+ _create_node_trace(self.team, with_trace_event=False)++ response = self.client.get(self._url("trace-1", _encode("trace-1")))++ assert response.status_code == 200+ assert response.json()["event"] is None++ @parameterized.expand(+ [+ ("unknown node", "trace-1", "00000000-0000-0000-0000-00000000ffff"),+ ("root of an unknown trace", "trace-2", "trace-2"),+ ("node of another trace", "trace-2", GENERATION),+ ]+ )+ def test_node_not_found(self, _name: str, trace_id: str, node_id: str) -> None:+ _create_node_trace(self.team)++ assert self.client.get(self._url(trace_id, _encode(node_id))).status_code == 404++ @parameterized.expand(+ [+ ("malformed trace segment", "A", _encode(GENERATION)),+ ("malformed node segment", _encode("trace-1"), "A"),+ ]+ )+ def test_rejects_a_malformed_segment(self, _name: str, trace_segment: str, node_segment: str) -> None:+ _create_node_trace(self.team)++ url = f"/api/projects/{self.team.id}/ai_observability/traces/{trace_segment}/nodes/{node_segment}/"+ assert self.client.get(url).status_code == 400++ def test_masks_properties_the_viewer_may_not_read(self) -> None:+ self.organization.available_product_features = [+ {"key": AvailableFeature.PROPERTY_ACCESS_CONTROL, "name": AvailableFeature.PROPERTY_ACCESS_CONTROL}+ ]+ self.organization.save()+ definition = PropertyDefinition.objects.create(+ team=self.team, name="secret_plan", property_type="String", type=PropertyDefinition.Type.EVENT+ )+ PropertyAccessControl.objects.create(+ team=self.team,+ property_definition=definition,+ organization_member=self.organization_membership,+ access_level=PropertyAccessLevel.NONE.value,+ )+ _create_node_trace(self.team, extra_properties={"secret_plan": "enterprise"})++ properties = self.client.get(self._url("trace-1", _encode(GENERATION))).json()["event"]["properties"]++ assert "secret_plan" not in properties+ assert properties["$ai_provider"] == "openai"++class TestTraceViewSetResourceLevelAccess(ClickhouseTestMixin, APIBaseTest):def test_a_grant_on_one_object_does_not_open_traces(self) -> None:self.organization.available_product_features = [diff --git a/products/ai_observability/frontend/generated/api.schemas.ts b/products/ai_observability/frontend/generated/api.schemas.tsindex e5c598199f66..bf167846c394 100644--- a/products/ai_observability/frontend/generated/api.schemas.ts+++ b/products/ai_observability/frontend/generated/api.schemas.ts@@ -1283,6 +1283,8 @@ export interface OfflineHistoryPageApi {results: OfflineHistoryPointApi[]}+export type TraceApiNodeIdsByAlias = { [key: string]: string }+export interface TracePersonApi {distinctId: stringlabel: string@@ -1339,6 +1341,45 @@ export interface TraceApi {timeline: TraceTimelineRowApi[]totalMs: numberthreadNodeIds: string[]+ defaultNodeId: string+ nodeIdsByAlias: TraceApiNodeIdsByAlias+}++export interface TraceNodeMetadataApi {+ provider: string | null+ temperature: number | null+ sessionId: string | null+ promptName: string | null+ promptVersion: number | null+}++export interface TraceNodeIOKeysApi {+ input: string | null+ output: string | null+ tools: string | null+}++/**+ * The event's properties as ingested, including its input and output values.+ */+export type TraceNodeEventApiProperties = { [key: string]: unknown }++export interface TraceNodeEventApi {+ name: string+ uuid: string+ timestamp: string+ /** The event's properties as ingested, including its input and output values. */+ properties: TraceNodeEventApiProperties+ /** Which keys of `properties` hold the node's input, output and tools, or null when it has none. */+ ioKeys: TraceNodeIOKeysApi+}++export interface TraceNodeDetailApi {+ id: string+ kind: TraceNodeKindEnumApi+ error: string | null+ metadata: TraceNodeMetadataApi+ event: TraceNodeEventApi | null}export type DatasetJSONValueApi = { [key: string]: unknown } | unknown[] | string | number | boolean@@ -5068,6 +5109,13 @@ export type AiObservabilityTracesRetrieveParams = {timestamp_hint?: string}+export type AiObservabilityTracesNodesRetrieveParams = {+ /**+ * When the trace happened, as carried by links into it. Lets a trace older than the AI events retention load from the shared events table.+ */+ timestamp_hint?: string+}+export type DatasetItemsListParams = {/*** Return archived items instead of active items.diff --git a/products/ai_observability/frontend/generated/api.ts b/products/ai_observability/frontend/generated/api.tsindex 2c9637cbd771..3d452f40baf0 100644--- a/products/ai_observability/frontend/generated/api.ts+++ b/products/ai_observability/frontend/generated/api.ts@@ -16,6 +16,7 @@ import type {AiObservabilityOfflineExperimentsResultCellsRetrieveParams,AiObservabilityOfflineExperimentsScorerSummariesListParams,AiObservabilityOfflineScorersHistoryListParams,+ AiObservabilityTracesNodesRetrieveParams,AiObservabilityTracesRetrieveParams,BatchCheckRequestApi,BatchCheckResponseApi,@@ -142,6 +143,7 @@ import type {TextReprRequestApi,TextReprResponseApi,TraceApi,+ TraceNodeDetailApi,TraceReviewApi,TraceReviewCreateApi,TranslateRequestApi,@@ -673,6 +675,43 @@ export const aiObservabilityTracesRetrieve = async (})}+export const getAiObservabilityTracesNodesRetrieveUrl = (+ projectId: string,+ id: string,+ nodeId: string,+ params?: AiObservabilityTracesNodesRetrieveParams+) => {+ const normalizedParams = new URLSearchParams()++ Object.entries(params || {}).forEach(([key, value]) => {+ if (value !== undefined) {+ normalizedParams.append(key, value === null ? 'null' : String(value))+ }+ })++ const stringifiedParams = normalizedParams.toString()++ return stringifiedParams.length > 0+ ? `/api/projects/${projectId}/ai_observability/traces/${id}/nodes/${nodeId}/?${stringifiedParams}`+ : `/api/projects/${projectId}/ai_observability/traces/${id}/nodes/${nodeId}/`+}++/**+ * One node of a trace: its event properties as ingested, the keys that hold its input, output and tools, its error and its metadata.+ */+export const aiObservabilityTracesNodesRetrieve = async (+ projectId: string,+ id: string,+ nodeId: string,+ params?: AiObservabilityTracesNodesRetrieveParams,+ options?: RequestInit+): Promise<TraceNodeDetailApi> => {+ return apiMutator<TraceNodeDetailApi>(getAiObservabilityTracesNodesRetrieveUrl(projectId, id, nodeId, params), {+ ...options,+ method: 'GET',+ })+}+export const getDatasetItemsListUrl = (projectId: string, params: DatasetItemsListParams) => {const normalizedParams = new URLSearchParams()diff --git a/products/ai_observability/frontend/redesign/trace/TraceScene.tsx b/products/ai_observability/frontend/redesign/trace/TraceScene.tsxindex bb721a04403c..8f7b25e1c86e 100644--- a/products/ai_observability/frontend/redesign/trace/TraceScene.tsx+++ b/products/ai_observability/frontend/redesign/trace/TraceScene.tsx@@ -25,6 +25,7 @@ interface ReadyActions {selectAndShowSpans: (id: string) => voidsetDetailTab: (tab: NodeDetailTab) => voidviewInThread: () => void+ prefetchNode: (id: string) => void}function toReadyProps(values: ReadyValues, actions: ReadyActions): TraceViewReadyProps | null {@@ -39,6 +40,7 @@ function toReadyProps(values: ReadyValues, actions: ReadyActions): TraceViewReadtree: values.tree,selectedNodeId: values.selectedNodeId,onSelectNode: actions.selectNode,+ onPrefetchNode: actions.prefetchNode,onSelectFromView: actions.selectAndShowSpans,detail: values.detailData? {@@ -54,8 +56,8 @@ function toReadyProps(values: ReadyValues, actions: ReadyActions): TraceViewRead}export function TraceScene(): JSX.Element {- const { traceId, query, dateRange } = useValues(aiObservabilityTraceLogic)- const logic = traceViewAdapterLogic({ traceId, query, timestampHint: dateRange?.dateFrom ?? null })+ const { traceId, dateRange } = useValues(aiObservabilityTraceLogic)+ const logic = traceViewAdapterLogic({ traceId, timestampHint: dateRange?.dateFrom ?? null })// Every kea value getter is a hook, so read them all on every render, whatever the status.const {status,diff --git a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/eventIO.test.tsdeleted file mode 100644index b5af1ef69dd0..000000000000--- a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.test.ts+++ /dev/null@@ -1,140 +0,0 @@-import { LLMTraceEvent } from '~/queries/schema/schema-general'--import { AIData } from '../../../aiObservabilityAIDataLogic'-import { heavyDataLookup, resolveEventIO } from './eventIO'-import { makeEvent } from './testFixtures'--interface ResolveEventIOCase {- name: string- event: LLMTraceEvent- cache: Record<string, AIData | null>- expected: { input: unknown; output: unknown; loading: boolean }-}--const resolveEventIOCases: ResolveEventIOCase[] = [- {- name: 'a generation with inline input and output',- event: makeEvent({- id: 'gen-1',- event: '$ai_generation',- properties: {- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],- $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],- },- }),- cache: {},- expected: {- input: [{ role: 'user', content: 'Why did my invoice go up?' }],- output: [{ role: 'assistant', content: 'Two seats were added.' }],- loading: false,- },- },- {- name: 'a generation missing input, with no cache entry yet',- event: makeEvent({ id: 'gen-2', event: '$ai_generation', properties: {} }),- cache: {},- expected: { input: undefined, output: undefined, loading: true },- },- {- name: 'a generation missing input, with a cache entry that found nothing',- event: makeEvent({ id: 'gen-3', event: '$ai_generation', properties: {} }),- cache: { 'gen-3': null },- expected: { input: undefined, output: undefined, loading: false },- },- {- name: 'a generation missing input, with a loaded cache entry',- event: makeEvent({ id: 'gen-4', event: '$ai_generation', properties: {} }),- cache: {- 'gen-4': {- input: [{ role: 'user', content: 'Cached question' }],- output: [{ role: 'assistant', content: 'Cached answer' }],- tools: null,- },- },- expected: {- input: [{ role: 'user', content: 'Cached question' }],- output: [{ role: 'assistant', content: 'Cached answer' }],- loading: false,- },- },- {- name: 'an embedding',- event: makeEvent({ id: 'emb-1', event: '$ai_embedding', properties: { $ai_input: 'embed this text' } }),- cache: {},- expected: { input: 'embed this text', output: null, loading: false },- },- {- name: 'a span',- event: makeEvent({- id: 'span-1',- event: '$ai_span',- properties: { $ai_input_state: { step: 1 }, $ai_output_state: { step: 2 } },- }),- cache: {},- expected: { input: { step: 1 }, output: { step: 2 }, loading: false },- },- {- name: 'an OTel span that carries generation-style input and output',- event: makeEvent({- id: 'span-2',- event: '$ai_span',- properties: {- $ai_input: [{ role: 'user', content: 'Suggest hashtags' }],- $ai_output_choices: 'Added #levelup',- },- }),- cache: {},- expected: { input: [{ role: 'user', content: 'Suggest hashtags' }], output: 'Added #levelup', loading: false },- },-]--describe('eventIO', () => {- describe('resolveEventIO', () => {- it.each(resolveEventIOCases)('$name', ({ event, cache, expected }) => {- expect(resolveEventIO(event, cache)).toEqual(expected)- })- })-- describe('heavyDataLookup', () => {- it('returns null for a generation with both input and output present', () => {- const event = makeEvent({- id: 'gen-1',- event: '$ai_generation',- properties: {- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],- $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],- },- })- expect(heavyDataLookup(event, 'trace-1')).toBeNull()- })-- it('returns null for a span', () => {- const event = makeEvent({- id: 'span-1',- event: '$ai_span',- properties: { $ai_input_state: { step: 1 }, $ai_output_state: { step: 2 } },- })- expect(heavyDataLookup(event, 'trace-1')).toBeNull()- })-- it('returns a lookup for a generation missing output', () => {- const event = makeEvent({- id: 'gen-2',- event: '$ai_generation',- createdAt: '2026-09-01T10:15:02Z',- properties: {- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],- $ai_tools: [{ name: 'lookup_invoice' }],- },- })- expect(heavyDataLookup(event, 'trace-1')).toEqual({- eventId: 'gen-2',- input: [{ role: 'user', content: 'Why did my invoice go up?' }],- output: undefined,- tools: [{ name: 'lookup_invoice' }],- traceId: 'trace-1',- timestamp: '2026-09-01T10:15:02Z',- })- })- })-})diff --git a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.ts b/products/ai_observability/frontend/redesign/trace/adapter/eventIO.tsdeleted file mode 100644index 0bccdd33fbba..000000000000--- a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.ts+++ /dev/null@@ -1,43 +0,0 @@-import { LLMTraceEvent } from '~/queries/schema/schema-general'--import { AIData, AIDataLookup } from '../../../aiObservabilityAIDataLogic'-import { getLLMEventKind, readAiInput, readAiOutput } from '../../../utils'--function generationOutput(event: LLMTraceEvent): unknown {- return event.properties.$ai_output_choices ?? event.properties.$ai_output-}--function isMissingGenerationData(event: LLMTraceEvent): boolean {- return event.properties.$ai_input == null || generationOutput(event) == null-}--export function heavyDataLookup(event: LLMTraceEvent, traceId: string): AIDataLookup | null {- if (getLLMEventKind(event) !== 'generation' || !isMissingGenerationData(event)) {- return null- }- return {- eventId: event.id,- input: event.properties.$ai_input,- output: generationOutput(event),- tools: event.properties.$ai_tools,- traceId,- timestamp: event.createdAt,- }-}--export function resolveEventIO(- event: LLMTraceEvent,- cache: Record<string, AIData | null>-): { input: unknown; output: unknown; loading: boolean } {- const kind = getLLMEventKind(event)- if (kind === 'generation') {- const cached = cache[event.id]- const input = cached?.input ?? event.properties.$ai_input- const output = cached?.output ?? generationOutput(event)- return { input, output, loading: isMissingGenerationData(event) && cached === undefined }- }- if (kind === 'embedding') {- return { input: event.properties.$ai_input, output: null, loading: false }- }- return { input: readAiInput(event.properties), output: readAiOutput(event.properties), loading: false }-}diff --git a/products/ai_observability/frontend/redesign/trace/adapter/nodeIO.ts b/products/ai_observability/frontend/redesign/trace/adapter/nodeIO.tsnew file mode 100644index 000000000000..74487155a1ea--- /dev/null+++ b/products/ai_observability/frontend/redesign/trace/adapter/nodeIO.ts@@ -0,0 +1,17 @@+import type { TraceNodeDetailApi } from '../../../generated/api.schemas'++export interface NodeIO {+ input: unknown+ output: unknown+}++export function readNodeIO(node: TraceNodeDetailApi): NodeIO {+ if (!node.event) {+ return { input: undefined, output: undefined }+ }+ const { properties, ioKeys } = node.event+ return {+ input: ioKeys.input ? properties[ioKeys.input] : undefined,+ output: ioKeys.output ? properties[ioKeys.output] : undefined,+ }+}diff --git a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.test.tsdeleted file mode 100644index 5c3d21dc4549..000000000000--- a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.test.ts+++ /dev/null@@ -1,14 +0,0 @@-import { readNumber } from './propertyReaders'--describe('readNumber', () => {- it.each([- ['', null],- [' ', null],- ['0.2', 0.2],- [0, 0],- ['abc', null],- [undefined, null],- ])('reads %p as %p', (input, expected) => {- expect(readNumber(input)).toBe(expected)- })-})diff --git a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.ts b/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.tsdeleted file mode 100644index 636c014d380d..000000000000--- a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.ts+++ /dev/null@@ -1,11 +0,0 @@-export function readString(value: unknown): string | null {- return typeof value === 'string' && value !== '' ? value : null-}--export function readNumber(value: unknown): number | null {- if (typeof value === 'string' && value.trim() === '') {- return null- }- const parsed = typeof value === 'string' ? Number(value) : value- return typeof parsed === 'number' && Number.isFinite(parsed) ? parsed : null-}diff --git a/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts b/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.tsindex 8b1368b5c07f..226e0d6a76de 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts@@ -1,6 +1,13 @@import { LLMTrace, LLMTraceEvent } from '~/queries/schema/schema-general'-import type { TraceApi, TraceNodeStatsApi } from '../../../generated/api.schemas'+import type {+ TraceApi,+ TraceNodeApi,+ TraceNodeDetailApi,+ TraceNodeIOKeysApi,+ TraceNodeMetadataApi,+ TraceNodeStatsApi,+} from '../../../generated/api.schemas'export function makeEvent(overrides: Partial<LLMTraceEvent> & { id: string }): LLMTraceEvent {return { event: '$ai_span', properties: {}, createdAt: '2026-09-01T10:15:00Z', ...overrides }@@ -30,6 +37,54 @@ const emptyStats: TraceNodeStatsApi = {latencyMs: null,}+export function decodeIdSegment(segment: string): string {+ const binary = atob(segment.replace(/-/g, '+').replace(/_/g, '/'))+ return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)))+}++interface NodeDetailFixture {+ id: string+ kind?: TraceNodeApi['kind']+ properties?: Record<string, unknown>+ ioKeys?: Partial<TraceNodeIOKeysApi>+ error?: string | null+ metadata?: Partial<TraceNodeMetadataApi>+ withEvent?: boolean+}++export function makeNodeDetail({+ id,+ kind = 'generation',+ properties = {},+ ioKeys = {},+ error = null,+ metadata = {},+ withEvent = true,+}: NodeDetailFixture): TraceNodeDetailApi {+ return {+ id,+ kind,+ error,+ metadata: {+ provider: null,+ temperature: null,+ sessionId: null,+ promptName: null,+ promptVersion: null,+ ...metadata,+ },+ event: withEvent+ ? {+ name: `$ai_${kind}`,+ uuid: id,+ timestamp: '2026-09-01T10:15:02Z',+ properties,+ ioKeys: { input: null, output: null, tools: null, ...ioKeys },+ }+ : null,+ }+}+export function makeTraceResource(overrides: Partial<TraceApi> = {}): TraceApi {const childIds = ['span-1', 'gen-1', 'gen-2']return {@@ -63,6 +118,8 @@ export function makeTraceResource(overrides: Partial<TraceApi> = {}): TraceApi {timeline: [],totalMs: 0,threadNodeIds: ['gen-2'],+ defaultNodeId: 'trace-1',+ nodeIdsByAlias: {},...overrides,}}diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.tsindex b9b3be013b2f..44f7c40e9914 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts@@ -1,8 +1,7 @@import { EvaluationRun } from '../../../evaluations/types'import type { TraceNodeApi } from '../../../generated/api.schemas'-import { isLLMEvent } from '../../../utils'-import { EvalResult, EvalsState } from '../types'-import { makeEvent, makeTrace } from './testFixtures'+import { EvalResult, EvalsState, NodeLoad } from '../types'+import { makeNodeDetail } from './testFixtures'import { toNodeDetail } from './toNodeDetail'const node = (id: string, kind: 'trace' | 'span' | 'generation'): TraceNodeApi => ({@@ -42,11 +41,11 @@ function readyResults(evals: EvalsState): EvalResult[] {return evals.results}+const ready = (detail: ReturnType<typeof makeNodeDetail>): NodeLoad => ({ status: 'ready', node: detail })+describe('toNodeDetail', () => {const base = {- trace: makeTrace(),tree: [],- cache: {},evalRuns: [],evalRunsLoading: false,evaluations: [],@@ -54,33 +53,45 @@ describe('toNodeDetail', () => {evaluationsSettled: true,teamId: 7,person: null,+ trace: { createdAt: '2026-09-01T10:15:00Z', sessionId: 'sess-1' },}- it('generation without inline IO and no cache entry yields loading', () => {- const event = makeEvent({ id: 'gen-1', event: '$ai_generation', properties: {} })- const detail = toNodeDetail({ ...base, event, node: node('gen-1', 'generation') })- expect(detail.content).toEqual({ kind: 'loading' })+ it.each<[string, NodeLoad, unknown]>([+ ['loading', { status: 'loading' }, { kind: 'loading' }],+ [+ 'not found',+ { status: 'error', failure: 'not_found' },+ {+ kind: 'error',+ message:+ 'This step could not be found. It may have been deleted, or it is outside the retention period.',+ },+ ],+ [+ 'failed',+ { status: 'error', failure: 'failed' },+ { kind: 'error', message: 'This step could not be loaded. Select it again to retry.' },+ ],+ ])('a %s node shows its load state, no raw event and no time', (_name, load, content) => {+ const detail = toNodeDetail({ ...base, node: node('gen-1', 'generation'), load })+ expect(detail.content).toEqual(content)+ expect(detail.raw).toBeNull()+ expect(detail.properties.timestamp).toBeNull()})- it('generation with content yields messages, properties and its own evals', () => {- const event = makeEvent({- id: 'gen-1',- event: '$ai_generation',- properties: {- $ai_input: [{ role: 'user', content: 'Hi' }],- $ai_output_choices: [{ role: 'assistant', content: 'Hello' }],- $ai_model: 'gpt-4.1-mini',- $ai_provider: 'openai',- $ai_temperature: 0.2,- $ai_session_id: 'sess-1',- $ai_prompt_name: 'billing-answer',- $ai_prompt_version: 6,- },- })+ it('generation reads its messages through the io keys and keeps its details, raw event and own evals', () => {+ const input = [{ role: 'user', content: 'Hi' }]const detail = toNodeDetail({...base,- event,node: node('gen-1', 'generation'),+ load: ready(+ makeNodeDetail({+ id: 'gen-1',+ properties: { $ai_input: input, $ai_output_choices: [{ role: 'assistant', content: 'Hello' }] },+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },+ metadata: { provider: 'openai', temperature: 0.2, sessionId: 'sess-9', promptVersion: 6 },+ })+ ),evalRuns: [run(), run({ id: 'r2', generation_id: 'gen-other' })],})expect(detail.content).toMatchObject({@@ -89,11 +100,13 @@ describe('toNodeDetail', () => {output: [{ role: 'assistant', parts: [{ kind: 'text', text: 'Hello' }] }],})expect(detail.properties).toMatchObject({+ timestamp: '2026-09-01T10:15:02Z',provider: 'openai',temperature: 0.2,- sessionId: 'sess-1',+ sessionId: 'sess-9',promptVersion: 6,})+ expect(detail.raw).toMatchObject({ event: '$ai_generation', uuid: 'gen-1', properties: { $ai_input: input } })expect(readyResults(detail.evals).map((result) => result.id)).toEqual(['r1'])})@@ -101,80 +114,79 @@ describe('toNodeDetail', () => {['eval runs are loading', { evalRunsLoading: true }],['the evaluation configs that decide detector polarity have not loaded', { evaluationsSettled: false }],])('reports evals as loading while %s', (_name, overrides) => {- const event = makeEvent({ id: 'gen-1', event: '$ai_generation', properties: {} })const detail = toNodeDetail({...base,...overrides,- event,node: node('gen-1', 'generation'),+ load: { status: 'loading' },evalRuns: [run()],})expect(detail.evals).toEqual({ status: 'loading' })})- it.each([- { name: 'a person label', person: '[email protected]' },- { name: 'no person', person: null },- ])(- 'span shows its state as input and output, surfaces its error, and labels the person with $name',- ({ person }) => {- const event = makeEvent({- id: 'span-1',- properties: {- $ai_input_state: { q: 'x' },- $ai_output_state: null,- $ai_is_error: true,- $ai_error: 'Timeout',- },- })- const detail = toNodeDetail({ ...base, event, node: node('span-1', 'span'), person })- expect(detail.content).toEqual({ kind: 'io', input: { q: 'x' }, output: undefined })- expect(detail.error).toBe('Timeout')- expect(detail.properties.person).toBe(person)- }- )+ it('span shows its state as input and output, surfaces its error and labels the person', () => {+ const detail = toNodeDetail({+ ...base,+ person: '[email protected]',+ node: node('span-1', 'span'),+ load: ready(+ makeNodeDetail({+ id: 'span-1',+ kind: 'span',+ properties: { $ai_input_state: { q: 'x' } },+ ioKeys: { input: '$ai_input_state' },+ error: 'Timeout',+ })+ ),+ })+ expect(detail.content).toEqual({ kind: 'io', input: { q: 'x' }, output: undefined })+ expect(detail.error).toBe('Timeout')+ expect(detail.properties.person).toBe('[email protected]')+ })- it('trace root shows the trace state and every eval run', () => {- const trace = makeTrace({ inputState: { question: 'Hi' }, outputState: { answer: 'Hello' } })+ it.each([+ ['with a trace event', true],+ ['without a trace event', false],+ ])('trace root %s takes its time and session from the trace and shows every eval run', (_name, withEvent) => {const detail = toNodeDetail({...base,- trace,- event: trace,node: node('trace-1', 'trace'),+ load: ready(+ makeNodeDetail({+ id: 'trace-1',+ kind: 'trace',+ withEvent,+ properties: { $ai_input_state: { question: 'Hi' } },+ ioKeys: { input: '$ai_input_state' },+ })+ ),evalRuns: [run(), run({ id: 'r2' })],})- expect(detail.content).toEqual({ kind: 'io', input: { question: 'Hi' }, output: { answer: 'Hello' } })+ expect(detail.properties).toMatchObject({ timestamp: '2026-09-01T10:15:00Z', sessionId: 'sess-1' })expect(readyResults(detail.evals)).toHaveLength(2)- expect(detail.raw).not.toHaveProperty('events')+ expect(detail.content).toEqual({+ kind: 'io',+ input: withEvent ? { question: 'Hi' } : undefined,+ output: undefined,+ })+ expect(detail.raw === null).toBe(!withEvent)})- it.each([- {- name: 'trace state holding message arrays',- event: makeTrace({- inputState: [{ role: 'user', content: 'Move my flight to Friday' }],- outputState: [{ role: 'assistant', content: 'Moved to Friday 09:15' }],- }),- kind: 'trace' as const,- },- {- name: 'an OTel span with a message array input and a text output',- event: makeEvent({- id: 'span-2',- properties: {- $ai_input: [{ role: 'user', content: 'Move my flight to Friday' }],- $ai_output_choices: 'Moved to Friday 09:15',- },- }),- kind: 'span' as const,- },- ])('renders $name as input and output messages', ({ event, kind }) => {- const trace = isLLMEvent(event) ? base.trace : event+ it('renders an OTel span with a message array input and a text output as messages', () => {const detail = toNodeDetail({...base,- trace,- event,- node: node(isLLMEvent(event) ? event.id : trace.id, kind),+ node: node('span-2', 'span'),+ load: ready(+ makeNodeDetail({+ id: 'span-2',+ kind: 'span',+ properties: {+ $ai_input: [{ role: 'user', content: 'Move my flight to Friday' }],+ $ai_output_choices: 'Moved to Friday 09:15',+ },+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },+ })+ ),})expect(detail.content).toMatchObject({kind: 'messages',diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.tsindex c624f6d138d4..27401e540e02 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts@@ -1,26 +1,23 @@-import { LLMTrace, LLMTraceEvent } from '~/queries/schema/schema-general'--import { AIData } from '../../../aiObservabilityAIDataLogic'import { EvaluationConfig, EvaluationRun } from '../../../evaluations/types'-import type { TraceNodeApi } from '../../../generated/api.schemas'-import { isLLMEvent } from '../../../utils'+import type { TraceNodeApi, TraceNodeDetailApi } from '../../../generated/api.schemas'import { NodeDetailProps } from '../components/NodeDetail'-import { EvalsState, NodeContent, NodeProperties } from '../types'-import { resolveEventIO } from './eventIO'-import { readNumber, readString } from './propertyReaders'+import { EvalsState, LoadFailure, NodeContent, NodeLoad, NodeProperties } from '../types'+import { NodeIO, readNodeIO } from './nodeIO'import { TeamId } from './toAttachment'import { toEvalResults } from './toEvalResults'import { toMessageIO } from './toThread'import { isMessageIO } from './toThreadMessages'-import { eventError } from './toTraceTree'export type NodeDetailData = Omit<NodeDetailProps, 'tab' | 'onTabChange' | 'onViewInThread' | 'onSelectNode'>+const NODE_LOAD_ERRORS: Record<LoadFailure, string> = {+ not_found: 'This step could not be found. It may have been deleted, or it is outside the retention period.',+ failed: 'This step could not be loaded. Select it again to retry.',+}+interface NodeDetailArgs {- trace: LLMTrace- event: LLMTrace | LLMTraceEventnode: TraceNodeApi- cache: Record<string, AIData | null>+ load: NodeLoadtree: TraceNodeApi[]evalRuns: EvaluationRun[]evalRunsLoading: boolean@@ -29,48 +26,56 @@ interface NodeDetailArgs {evaluationsSettled: booleanteamId: TeamIdperson: string | null+ trace: { createdAt: string; sessionId: string | null }}-function ioContent(io: { input: unknown; output: unknown }, node: TraceNodeApi, teamId: TeamId): NodeContent {+function ioContent(io: NodeIO, node: TraceNodeApi, teamId: TeamId): NodeContent {if (node.kind === 'generation' || isMessageIO(io.input, io.output)) {return { kind: 'messages', ...toMessageIO(io, node.id, teamId) }}return { kind: 'io', input: io.input, output: io.output }}-function eventContent(- event: LLMTraceEvent,- node: TraceNodeApi,- cache: Record<string, AIData | null>,- teamId: TeamId-): NodeContent {- const io = resolveEventIO(event, cache)- return io.loading ? { kind: 'loading' } : ioContent(io, node, teamId)+function loadedContent(load: NodeLoad, node: TraceNodeApi, teamId: TeamId): NodeContent {+ switch (load.status) {+ case 'loading':+ return { kind: 'loading' }+ case 'error':+ return { kind: 'error', message: NODE_LOAD_ERRORS[load.failure] }+ case 'ready':+ return ioContent(readNodeIO(load.node), node, teamId)+ }}-function eventProperties(event: LLMTraceEvent, person: string | null): NodeProperties {- const properties = event.properties+function nodeProperties(load: NodeLoad, node: TraceNodeApi, args: NodeDetailArgs): NodeProperties {+ if (node.kind === 'trace') {+ return {+ timestamp: args.trace.createdAt,+ provider: null,+ temperature: null,+ sessionId: args.trace.sessionId,+ promptName: null,+ promptVersion: null,+ person: args.person,+ }+ }+ const detail = load.status === 'ready' ? load.node : nullreturn {- timestamp: event.createdAt,- provider: readString(properties.$ai_provider),- temperature: readNumber(properties.$ai_temperature),- sessionId: readString(properties.$ai_session_id),- promptName: readString(properties.$ai_prompt_name),- promptVersion: readNumber(properties.$ai_prompt_version),- person,+ timestamp: detail?.event?.timestamp ?? null,+ provider: detail?.metadata.provider ?? null,+ temperature: detail?.metadata.temperature ?? null,+ sessionId: detail?.metadata.sessionId ?? null,+ promptName: detail?.metadata.promptName ?? null,+ promptVersion: detail?.metadata.promptVersion ?? null,+ person: args.person,}}-function traceProperties(trace: LLMTrace, person: string | null): NodeProperties {- return {- timestamp: trace.createdAt,- provider: null,- temperature: null,- sessionId: trace.aiSessionId ?? null,- promptName: null,- promptVersion: null,- person,- }+function rawEvent(detail: TraceNodeDetailApi): Record<string, unknown> | null {+ const { event } = detail+ return event+ ? { event: event.name, uuid: event.uuid, timestamp: event.timestamp, properties: event.properties }+ : null}// Detector polarity comes from the evaluation configs, so results wait for them to avoid showing a flipped verdict.@@ -90,27 +95,14 @@ function evalsState(runs: EvaluationRun[], node: TraceNodeApi, args: NodeDetailA}export function toNodeDetail(args: NodeDetailArgs): NodeDetailData {- const { trace, event, node, cache, evalRuns, teamId, person } = args+ const { node, load, evalRuns, teamId } = argsconst runs = node.kind === 'trace' ? evalRuns : evalRuns.filter((run) => run.generation_id === node.id)- const evals = evalsState(runs, node, args)-- if (!isLLMEvent(event)) {- const { events: _events, ...raw } = trace- return {- node,- content: ioContent({ input: trace.inputState, output: trace.outputState }, node, teamId),- error: null,- properties: traceProperties(trace, person),- evals,- raw,- }- }return {node,- content: eventContent(event, node, cache, teamId),- error: eventError(event),- properties: eventProperties(event, person),- evals,- raw: { event: event.event, id: event.id, createdAt: event.createdAt, properties: event.properties },+ content: loadedContent(load, node, teamId),+ error: load.status === 'ready' ? load.node.error : null,+ properties: nodeProperties(load, node, args),+ evals: evalsState(runs, node, args),+ raw: load.status === 'ready' ? rawEvent(load.node) : null,}}diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.tsindex 9579d6343e3b..1a9e938cb61f 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts@@ -1,5 +1,5 @@-import { ConversationState, ConversationTurn } from '../types'-import { makeEvent, makeTrace } from './testFixtures'+import { ConversationState, ConversationTurn, NodeLoad } from '../types'+import { makeNodeDetail } from './testFixtures'import { toThread } from './toThread'function readyTurns(thread: ConversationState): ConversationTurn[] {@@ -10,22 +10,25 @@ function readyTurns(thread: ConversationState): ConversationTurn[] {}describe('toThread', () => {- const generation = makeEvent({- id: 'gen-1',- event: '$ai_generation',- createdAt: '2026-09-01T10:15:02Z',- properties: {- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],- $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],- },+ const base = { traceId: 'trace-1', createdAt: '2026-09-01T10:15:00Z', teamId: 7 }+ const answered = (error: string | null = null): NodeLoad => ({+ status: 'ready',+ node: makeNodeDetail({+ id: 'gen-1',+ error,+ properties: {+ $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],+ $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],+ },+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },+ }),})- it('builds one turn for the trace from its user-visible generation', () => {- const thread = toThread(makeTrace({ events: [generation] }), {}, 7)+ it('builds one turn for the trace from its thread node', () => {+ const thread = toThread({ ...base, load: answered() })expect(thread).toMatchObject({ status: 'ready', activeTurnId: 'trace-1' })const turns = readyTurns(thread)- expect(turns).toHaveLength(1)- expect(turns[0].messages.map((m) => [m.role, m.sourceNodeId])).toEqual([+ expect(turns[0].messages.map((message) => [message.role, message.sourceNodeId])).toEqual([['user', 'gen-1'],['assistant', 'gen-1'],])@@ -33,40 +36,23 @@ describe('toThread', () => {})it('carries the error of a failed generation on its turn', () => {- const failed = makeEvent({- id: 'gen-3',- event: '$ai_generation',- properties: {- $ai_input: [{ role: 'user', content: 'Describe this photo.' }],- $ai_output_choices: [],- $ai_is_error: true,- $ai_error: 'Model does not support image input',- },- })- expect(readyTurns(toThread(makeTrace({ events: [failed] }), {}, 7))[0].error).toBe(+ expect(readyTurns(toThread({ ...base, load: answered('Model does not support image input') }))[0].error).toBe('Model does not support image input')})- it.each([- ['is loading while its offloaded content is not cached', {}, { status: 'loading' }],+ it.each<[string, NodeLoad, ConversationState]>([+ ['loading', { status: 'loading' }, { status: 'loading' }],[- 'uses its offloaded content once cached',- {- 'gen-2': {- input: [{ role: 'user', content: 'Hi' }],- output: [{ role: 'assistant', content: 'Hello' }],- tools: null,- },- },- { status: 'ready', turns: [{ messages: [{ role: 'user' }, { role: 'assistant' }] }] },+ 'failed',+ { status: 'error', failure: 'failed' },+ { status: 'error', message: 'The conversation could not be loaded. Reload the page to try again.' },],- ])('an offloaded generation %s', (_name, cache, expected) => {- const offloaded = makeEvent({ id: 'gen-2', event: '$ai_generation', properties: {} })- expect(toThread(makeTrace({ events: [offloaded] }), cache, 7)).toMatchObject(expected)+ ])('a thread whose node is %s', (_name, load, expected) => {+ expect(toThread({ ...base, load })).toEqual(expected)})- it('gives an empty turn when the trace has no generation', () => {- expect(readyTurns(toThread(makeTrace({ events: [makeEvent({ id: 's1' })] }), {}, 7))[0].messages).toEqual([])+ it('gives an empty turn when the trace has no thread node', () => {+ expect(readyTurns(toThread({ ...base, load: null }))[0].messages).toEqual([])})})diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts b/products/ai_observability/frontend/redesign/trace/adapter/toThread.tsindex b0d66f82361c..aef26e21aea7 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts@@ -1,12 +1,7 @@-import { LLMTrace } from '~/queries/schema/schema-general'--import { AIData } from '../../../aiObservabilityAIDataLogic'-import { pickUserVisibleTurn } from '../../../extractSessionTurns'-import { ConversationState, ThreadMessage } from '../types'-import { resolveEventIO } from './eventIO'+import { ConversationState, NodeLoad, ThreadMessage } from '../types'+import { readNodeIO } from './nodeIO'import { TeamId } from './toAttachment'import { toThreadMessages } from './toThreadMessages'-import { eventError } from './toTraceTree'export interface MessageIO {input: ThreadMessage[]@@ -30,23 +25,36 @@ export function toMessageIO(io: { input: unknown; output: unknown }, sourceNodeI}}-function readyThread(trace: LLMTrace, messages: ThreadMessage[], error: string | null): ConversationState {- return {- status: 'ready',- turns: [{ id: trace.id, timestamp: trace.createdAt, messages, error }],- activeTurnId: trace.id,- }+const THREAD_LOAD_ERROR = 'The conversation could not be loaded. Reload the page to try again.'++interface ThreadArgs {+ traceId: string+ createdAt: string+ load: NodeLoad | null+ teamId: TeamId+}++function readyThread(+ traceId: string,+ createdAt: string,+ messages: ThreadMessage[],+ error: string | null+): ConversationState {+ return { status: 'ready', turns: [{ id: traceId, timestamp: createdAt, messages, error }], activeTurnId: traceId }}-export function toThread(trace: LLMTrace, cache: Record<string, AIData | null>, teamId: TeamId): ConversationState {- const turnEvent = pickUserVisibleTurn(trace)- if (!turnEvent) {- return readyThread(trace, [], null)+export function toThread({ traceId, createdAt, load, teamId }: ThreadArgs): ConversationState {+ if (load === null) {+ return readyThread(traceId, createdAt, [], null)}- const io = resolveEventIO(turnEvent, cache)- if (io.loading) {- return { status: 'loading' }+ switch (load.status) {+ case 'loading':+ return { status: 'loading' }+ case 'error':+ return { status: 'error', message: THREAD_LOAD_ERROR }+ case 'ready': {+ const { input, output } = toMessageIO(readNodeIO(load.node), load.node.id, teamId)+ return readyThread(traceId, createdAt, [...input, ...output], load.node.error)+ }}- const { input, output } = toMessageIO(io, turnEvent.id, teamId)- return readyThread(trace, [...input, ...output], eventError(turnEvent))}diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.test.tsdeleted file mode 100644index da29766b93e9..000000000000--- a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.test.ts+++ /dev/null@@ -1,15 +0,0 @@-import { makeEvent } from './testFixtures'-import { isErrorEvent } from './toTraceTree'--describe('toTraceTree', () => {- describe('isErrorEvent', () => {- it.each([- ['a populated $ai_error with no flag', { $ai_error: 'boom' }, true],- ['$ai_is_error: true with no error payload', { $ai_is_error: true }, true],- ['$ai_is_error: "true" (SDK-serialized boolean)', { $ai_is_error: 'true' }, true],- ['neither an error payload nor a truthy flag', { $ai_is_error: false }, false],- ])('%s -> %s', (_description, properties, expected) => {- expect(isErrorEvent(makeEvent({ id: 'e1', properties }))).toBe(expected)- })- })-})diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts b/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.tsindex 706de6eeb5f3..adbc20d8b2cd 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts@@ -1,16 +1,4 @@-import { LLMTraceEvent } from '~/queries/schema/schema-general'-import type { TraceNodeApi } from '../../../generated/api.schemas'-import { toDisplayText } from '../components/jsonText'--export function isErrorEvent(event: LLMTraceEvent): boolean {- const isErrorFlag = event.properties.$ai_is_error- return !!event.properties.$ai_error || isErrorFlag === true || isErrorFlag === 'true'-}--export function eventError(event: LLMTraceEvent): string | null {- return isErrorEvent(event) ? toDisplayText(event.properties.$ai_error ?? 'This step failed.') : null-}export function findTreeNode(nodes: TraceNodeApi[], id: string): TraceNodeApi | null {for (const node of nodes) {diff --git a/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx b/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsxindex 186bd79ce5f9..35072fd85e89 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx+++ b/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx@@ -11,7 +11,7 @@ import { initKeaTests } from '~/test/init'import { aiObservabilityTraceLogic } from '../../../aiObservabilityTraceLogic'import { TraceScene } from '../TraceScene'-import { makeEvent, makeTrace, makeTraceResource } from './testFixtures'+import { decodeIdSegment, makeEvent, makeNodeDetail, makeTrace, makeTraceResource } from './testFixtures'const FLAG = FEATURE_FLAGS.AI_OBSERVABILITY_TRACE_REDESIGN@@ -21,6 +21,25 @@ jest.mock('../../../utils', () => ({queryEvaluationRuns: jest.fn().mockResolvedValue([]),}))+const TRACE_URL = '/api/projects/:team_id/ai_observability/traces/:id/'+const NODE_URL = '/api/projects/:team_id/ai_observability/traces/:id/nodes/:node_id/'+const answeredGeneration = makeNodeDetail({+ id: 'gen-2',+ properties: {+ $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],+ $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],+ },+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },+})+let nodeRequests: string[] = []+const nodeMock = {+ [NODE_URL]: ({ params }: { params: Record<string, unknown> }) => {+ const nodeId = decodeIdSegment(String(params.node_id))+ nodeRequests.push(nodeId)+ return [200, nodeId === 'gen-2' ? answeredGeneration : makeNodeDetail({ id: nodeId })]+ },+}+const generation = makeEvent({id: 'gen-1',event: '$ai_generation',@@ -33,36 +52,49 @@ const generation = makeEvent({},})+function renderNewView(): ReturnType<typeof render> {+ initKeaTests()+ nodeRequests = []+ jest.mocked(performQuery).mockReset()+ jest.mocked(performQuery).mockResolvedValue({ results: [] })+ aiObservabilityTraceLogic.mount()+ router.actions.push(urls.aiObservabilityTrace('trace-1'))+ return render(<TraceScene />)+}+describe('TraceScene', () => {afterEach(cleanup)- it('renders the loaded trace after showing the loading state', async () => {- initKeaTests()- type QueryResult = Awaited<ReturnType<typeof performQuery>>- let resolveQuery: (value: QueryResult) => void = () => {}- jest.mocked(performQuery).mockReturnValue(- new Promise<QueryResult>((resolve) => {- resolveQuery = resolve- })- )- useMocks({ get: { '/api/projects/:team_id/ai_observability/traces/:id/': () => [200, makeTraceResource()] } })- aiObservabilityTraceLogic.mount()- router.actions.push(urls.aiObservabilityTrace('trace-1'))-- const { findAllByText, queryByText } = render(<TraceScene />)- expect(queryByText('answer-billing-question')).toBeNull()-- resolveQuery({ results: [makeTrace({ events: [generation] })] })-- expect((await findAllByText('answer-billing-question')).length).toBeGreaterThan(0)- await waitFor(() => expect(queryByText('Two seats were added.')).not.toBeNull())+ describe('the new view', () => {+ beforeEach(() => {+ useMocks({ get: { [TRACE_URL]: () => [200, makeTraceResource({ defaultNodeId: 'gen-2' })], ...nodeMock } })+ })++ it('opens on the default node without the legacy trace query', async () => {+ const { findAllByText, findByText } = renderNewView()++ expect((await findAllByText('answer-billing-question')).length).toBeGreaterThan(0)+ expect(await findByText('Two seats were added.')).toBeTruthy()+ expect(jest.mocked(performQuery).mock.calls.some(([query]) => query.kind === 'TraceQuery')).toBe(false)+ })++ it('starts reading a step when the pointer rests on its row', async () => {+ const { findByText } = renderNewView()+ const row = (await findByText('span-1')).closest('[data-attr="trace-view-tree-node"]')+ if (!row) {+ throw new Error('expected span-1 to render as a tree row')+ }+ nodeRequests = []++ fireEvent.mouseEnter(row)++ await waitFor(() => expect(nodeRequests).toContain('span-1'))+ })})describe('behind the flag gate', () => {beforeEach(() => {- useMocks({- get: { '/api/projects/:team_id/ai_observability/traces/:id/': () => [200, makeTraceResource()] },- })+ useMocks({ get: { [TRACE_URL]: () => [200, makeTraceResource()], ...nodeMock } })})async function renderTraceRoute(flagEnabled: boolean): Promise<ReturnType<typeof render>> {diff --git a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.tsindex b987d20ffaa7..39b16099d8f5 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts@@ -1,5 +1,7 @@+import { waitFor } from '@testing-library/react'import { router } from 'kea-router'import { expectLogic } from 'kea-test-utils'+import posthog from 'posthog-js'import { urls } from 'scenes/urls'@@ -7,9 +9,9 @@ import { useMocks } from '~/mocks/jest'import { performQuery } from '~/queries/query'import { initKeaTests } from '~/test/init'-import { aiObservabilityAIDataLogic } from '../../../aiObservabilityAIDataLogic'import { aiObservabilityTraceLogic } from '../../../aiObservabilityTraceLogic'-import { makeEvent, makeTrace, makeTraceResource } from './testFixtures'+import type { TraceApi } from '../../../generated/api.schemas'+import { decodeIdSegment, makeNodeDetail, makeTraceResource } from './testFixtures'import { traceViewAdapterLogic } from './traceViewAdapterLogic'jest.mock('~/queries/query', () => ({ ...jest.requireActual('~/queries/query'), performQuery: jest.fn() }))@@ -18,95 +20,191 @@ jest.mock('../../../utils', () => ({queryEvaluationRuns: jest.fn().mockResolvedValue([]),}))-const offloadedGeneration = makeEvent({- id: 'gen-1',- event: '$ai_generation',- createdAt: '2026-09-01T10:15:02Z',- properties: { $ai_trace_id: 'trace-1', $ai_parent_id: 'trace-1' },-})+const TRACE_URL = '/api/projects/:team_id/ai_observability/traces/:id/'+const NODE_URL = '/api/projects/:team_id/ai_observability/traces/:id/nodes/:node_id/'-// The latest generation, so `pickUserVisibleTurn` picks this one for the thread. Carries-// inline input/output so `toThread` produces messages tagged with this event's id.-const answeredGeneration = makeEvent({+const answeredGeneration = makeNodeDetail({id: 'gen-2',- event: '$ai_generation',- createdAt: '2026-09-01T10:15:03Z',properties: {- $ai_trace_id: 'trace-1',- $ai_parent_id: 'trace-1',$ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],$ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],},-})--const offloadedLatestGeneration = makeEvent({- id: 'gen-3',- event: '$ai_generation',- createdAt: '2026-09-01T10:15:04Z',- properties: { $ai_trace_id: 'trace-1', $ai_parent_id: 'trace-1' },-})--const unrelatedSpan = makeEvent({- id: 'span-1',- event: '$ai_span',- createdAt: '2026-09-01T10:15:01Z',- properties: { $ai_trace_id: 'trace-1', $ai_parent_id: 'trace-1' },+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },})describe('traceViewAdapterLogic', () => {let logic: ReturnType<typeof traceViewAdapterLogic.build>-- function remount(): void {- logic.unmount()- const { query } = aiObservabilityTraceLogic.values- logic = traceViewAdapterLogic({ traceId: 'trace-1', query, timestampHint: null })+ let traceResource: TraceApi+ let traceGate: Promise<void>+ let nodeRequests: string[]+ let failingNodeId: string | null++ function mountAt(params: Record<string, string> = {}): void {+ router.actions.push(urls.aiObservabilityTrace('trace-1', params))+ logic = traceViewAdapterLogic({ traceId: 'trace-1', timestampHint: null })logic.mount()}- beforeEach(async () => {- useMocks({ get: { '/api/projects/:team_id/ai_observability/traces/:id/': () => [200, makeTraceResource()] } })+ beforeEach(() => {+ traceResource = makeTraceResource({ nodeIdsByAlias: { 'sdk-gen-1': 'gen-1' } })+ traceGate = Promise.resolve()+ nodeRequests = []+ failingNodeId = null+ useMocks({+ get: {+ [TRACE_URL]: async () => {+ await traceGate+ return [200, traceResource]+ },+ [NODE_URL]: ({ params }) => {+ const nodeId = decodeIdSegment(String(params.node_id))+ nodeRequests.push(nodeId)+ if (nodeId === failingNodeId) {+ failingNodeId = null+ return [500, { detail: 'Server error.' }]+ }+ if (nodeId === 'gen-2') {+ return [200, answeredGeneration]+ }+ const known = ['trace-1', 'span-1', 'gen-1'].includes(nodeId)+ return known ? [200, makeNodeDetail({ id: nodeId })] : [404, { detail: 'Node not found.' }]+ },+ },+ })initKeaTests()- jest.mocked(performQuery).mockResolvedValue({- results: [makeTrace({ events: [offloadedGeneration, answeredGeneration, unrelatedSpan] })],- } as any)+ jest.mocked(performQuery).mockReset()+ jest.mocked(performQuery).mockResolvedValue({ results: [] })aiObservabilityTraceLogic.mount()- router.actions.push(urls.aiObservabilityTrace('trace-1'))- const { query } = aiObservabilityTraceLogic.values- logic = traceViewAdapterLogic({ traceId: 'trace-1', query, timestampHint: null })- logic.mount()- await expectLogic(logic).toFinishAllListeners().toMatchValues({ status: 'ready' })})- afterEach(() => logic.unmount())+ afterEach(() => {+ logic.unmount()+ jest.restoreAllMocks()+ })++ it('reads a deep-linked node alongside the trace, then the thread node, and never runs the legacy trace query', async () => {+ let releaseTrace = (): void => {}+ traceGate = new Promise<void>((resolve) => {+ releaseTrace = resolve+ })+ mountAt({ event: 'span-1' })++ await waitFor(() => expect(nodeRequests).toEqual(['span-1']))+ expect(logic.values.status).toBe('loading')++ releaseTrace()+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ status: 'ready', selectedNodeId: 'span-1' })++ expect(nodeRequests).toEqual(['span-1', 'gen-2'])+ expect(jest.mocked(performQuery).mock.calls.some(([query]) => query.kind === 'TraceQuery')).toBe(false)+ })it.each([- ['a generation when it is selected', null, () => logic.actions.selectNode('gen-1'), 'gen-1'],- [- 'the offloaded latest generation, which the thread shows, on mount',- [answeredGeneration, offloadedLatestGeneration],- null,- 'gen-3',- ],- ])('asks the heavy-data loader for %s', async (_name, events, act, expectedEventId) => {- if (events) {- jest.mocked(performQuery).mockResolvedValue({ results: [makeTrace({ events })] } as any)- }- await expectLogic(logic, () => (act ? act() : remount())).toDispatchActions([- (action) =>- action.type === aiObservabilityAIDataLogic.actionTypes.ensureAIDataLoaded &&- action.payload.lookups.some((lookup: { eventId: string }) => lookup.eventId === expectedEventId),+ ['a node in the tree', { event: 'span-1' }, 'span-1'],+ ['an SDK id through its alias', { event: 'sdk-gen-1' }, 'gen-1'],+ ['a stale id as the root', { event: 'missing' }, 'trace-1'],+ ['no id as the default node', {}, 'gen-1'],+ ['a trace-level link as the root', { tab: 'summary' }, 'trace-1'],+ ])('selects %s', async (_name, params: Record<string, string>, expected) => {+ traceResource = makeTraceResource({ defaultNodeId: 'gen-1', nodeIdsByAlias: { 'sdk-gen-1': 'gen-1' } })+ mountAt(params)++ await expectLogic(logic).toFinishAllListeners().toMatchValues({ selectedNodeId: expected })+ expect(logic.values.detailData?.content.kind).not.toBe('error')+ })++ it('asks for the neighbours once the trace arrives', async () => {+ mountAt()++ await expectLogic(logic).toDispatchActions([+ aiObservabilityTraceLogic.actionCreators.loadNeighbors('trace-1', '2026-09-01T10:15:00Z'),])})- it('falls back to the root node when the event id is unknown', async () => {- await expectLogic(logic, () => logic.actions.selectNode('does-not-exist')).toMatchValues({- selectedNodeId: 'trace-1',- canViewInThread: true,+ it('reports the reads that open the view as navigation and a click on an unread step as a selection', async () => {+ const capture = jest.spyOn(posthog, 'capture')+ traceResource = makeTraceResource({ defaultNodeId: 'gen-1' })+ mountAt()+ await expectLogic(logic).toFinishAllListeners()++ expect(nodeRequests).toContain('gen-1')+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: expect.any(Number),+ trigger: 'navigation',+ waited_ms: null,+ })+ expect(capture).not.toHaveBeenCalledWith(+ 'llma trace node loaded',+ expect.objectContaining({ trigger: 'selection' })+ )+ capture.mockClear()++ logic.actions.selectNode('span-1')+ await expectLogic(logic).toFinishAllListeners()++ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: expect.any(Number),+ trigger: 'selection',+ waited_ms: expect.any(Number),})})+ it('prefetches only the row the pointer rests on, without rebuilding the shown step or the thread', async () => {+ mountAt()+ await expectLogic(logic).toFinishAllListeners()+ nodeRequests = []+ const { detailData, thread } = logic.values++ logic.actions.prefetchNode('span-1')+ logic.actions.prefetchNode('gen-1')+ await expectLogic(logic).toFinishAllListeners()++ expect(nodeRequests).toEqual(['gen-1'])+ expect(logic.values.detailData).toBe(detailData)+ expect(logic.values.thread).toBe(thread)+ })++ it('builds the thread from the thread node', async () => {+ mountAt()++ await expectLogic(logic)+ .toFinishAllListeners()+ .toMatchValues({+ thread: expect.objectContaining({+ status: 'ready',+ turns: [+ expect.objectContaining({+ messages: [+ expect.objectContaining({ role: 'user' }),+ expect.objectContaining({ role: 'assistant' }),+ ],+ }),+ ],+ }),+ })+ })++ it.each(['selectNode', 'selectAndShowSpans'] as const)(+ 'reads a failed node again when %s picks it again',+ async (select) => {+ failingNodeId = 'span-1'+ mountAt({ event: 'span-1' })+ await expectLogic(logic).toFinishAllListeners()+ expect(logic.values.detailData?.content.kind).toBe('error')++ logic.actions[select]('span-1')+ await expectLogic(logic).toFinishAllListeners()++ expect(nodeRequests.filter((nodeId) => nodeId === 'span-1')).toHaveLength(2)+ expect(logic.values.detailData?.content.kind).toBe('io')+ }+ )+it('selecting from the thread or timeline switches to spans', async () => {+ mountAt()+ await expectLogic(logic).toFinishAllListeners()logic.actions.setMode('timeline')+await expectLogic(logic, () => logic.actions.selectAndShowSpans('gen-1')).toMatchValues({mode: 'spans',selectedNodeId: 'gen-1',@@ -114,30 +212,13 @@ describe('traceViewAdapterLogic', () => {})it.each([- ['gen-2', 'a generation whose messages the thread carries', true],- ['span-1', 'a span the thread never mentions', false],+ ['gen-2', 'the thread node', true],+ ['trace-1', 'the root', true],+ ['span-1', 'a span outside the thread', false],])('canViewInThread for %s (%s) is %s', async (nodeId, _description, expected) => {- await expectLogic(logic, () => logic.actions.selectNode(nodeId)).toMatchValues({ canViewInThread: expected })- })+ mountAt()+ await expectLogic(logic).toFinishAllListeners()- it('clears a search query left over from a shared legacy URL, so it does not silently filter the tree, and keeps the other params', async () => {- router.actions.push(- urls.aiObservabilityTrace('trace-1', {- search: 'does-not-match-anything',- event: 'gen-2',- line: '4',- back_to: 'generations',- date_from: '-7d',- })- )- remount()-- await expectLogic(logic).toFinishAllListeners().toMatchValues({ status: 'ready' })- expect(router.values.searchParams).toEqual({- event: 'gen-2',- line: 4,- back_to: 'generations',- date_from: '-7d',- })+ await expectLogic(logic, () => logic.actions.selectNode(nodeId)).toMatchValues({ canViewInThread: expected })})})diff --git a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.tsindex 343305b60f61..43eb6fdb93ba 100644--- a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts+++ b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts@@ -1,25 +1,18 @@-import { MakeLogicType, actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'+import { MakeLogicType, actions, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'import { router } from 'kea-router'import { subscriptions } from 'kea-subscriptions'import { teamLogic } from 'scenes/teamLogic'-import { DataTableNode, LLMTrace, LLMTraceEvent } from '~/queries/schema/schema-general'--import { AIData, AIDataLookup, aiObservabilityAIDataLogic } from '../../../aiObservabilityAIDataLogic'-import { aiObservabilityTraceDataLogic } from '../../../aiObservabilityTraceDataLogic'import { aiObservabilityTraceLogic } from '../../../aiObservabilityTraceLogic'import { llmEvaluationsLogic } from '../../../evaluations/llmEvaluationsLogic'import { EvaluationConfig, EvaluationRun } from '../../../evaluations/types'-import { pickUserVisibleTurn } from '../../../extractSessionTurns'import type { TraceNodeApi, TraceTimelineRowApi } from '../../../generated/api.schemas'import { generationEvaluationRunsLogic } from '../../../generationEvaluationRunsLogic'-import { isLLMEvent } from '../../../utils'import { TraceHeaderProps } from '../components/TraceHeader'import { TraceSummaryBarProps } from '../components/TraceSummaryBar'import { TraceViewStatus, traceViewLogic } from '../traceViewLogic'-import { ConversationState, LabeledLink, NodeDetailTab, TraceMode } from '../types'-import { heavyDataLookup } from './eventIO'+import { ConversationState, LabeledLink, NodeDetailTab, NodeLoad, TraceMode } from '../types'import { toBackLink, toHeader } from './toHeader'import { NodeDetailData, toNodeDetail } from './toNodeDetail'import { toThread } from './toThread'@@ -27,15 +20,13 @@ import { findTreeNode } from './toTraceTree'export interface TraceViewAdapterLogicProps {traceId: string- query: DataTableNodetimestampHint: string | null}// Generated by kea-typegen. Update if you're an agent, ignore if you're human.export interface traceViewAdapterLogicValues {- aiDataCache: Record<string, AIData | null> // aiObservabilityAIDataLogic- event: LLMTrace | LLMTraceEvent | null // aiObservabilityTraceDataLogic- trace: LLMTrace | undefined // aiObservabilityTraceDataLogic+ eventId: string | null // aiObservabilityTraceLogic+ initialTab: string | null // aiObservabilityTraceLogicnewerTimestamp: string | null // aiObservabilityTraceLogicnewerTraceId: string | null // aiObservabilityTraceLogicolderTimestamp: string | null // aiObservabilityTraceLogic@@ -47,10 +38,16 @@ export interface traceViewAdapterLogicValues {evaluationsSettled: boolean // llmEvaluationsLogicsearchParams: Record<string, any> // routercurrentTeamId: number | null // teamLogic+ createdAt: string | null // traceViewLogic+ defaultNodeId: string // traceViewLogicerrorMessage: string // traceViewLogic+ nodeIdsByAlias: Record<string, string> // traceViewLogic+ nodes: Record<string, NodeLoad> // traceViewLogicpersonLabel: string | null // traceViewLogic+ sessionId: string | null // traceViewLogicstatus: TraceViewStatus // traceViewLogicsummary: TraceSummaryBarProps | null // traceViewLogic+ threadNodeIds: string[] // traceViewLogictimeline: {rows: TraceTimelineRowApi[]totalMs: number@@ -63,21 +60,43 @@ export interface traceViewAdapterLogicValues {detailData: NodeDetailData | nulldetailTab: NodeDetailTabheader: TraceHeaderProps- heavyDataLookups: AIDataLookup[]mode: TraceMode- selectedNodeId: string | null+ selectedNodeId: string+ selectedNodeLoad: NodeLoadselectedTreeNode: TraceNodeApi | nullthread: ConversationState+ threadNodeLoad: NodeLoad | null}// Generated by kea-typegen. Update if you're an agent, ignore if you're human.export interface traceViewAdapterLogicActions {- ensureAIDataLoaded: (lookups: AIDataLookup[]) => {- lookups: AIDataLookup[]- } // aiObservabilityAIDataLogic+ loadNeighbors: (+ traceId: string,+ timestamp: string+ ) => {+ timestamp: string+ traceId: string+ } // aiObservabilityTraceLogicsetEventId: (eventId: string | null) => {eventId: string | null} // aiObservabilityTraceLogic+ loadNode: (+ nodeId: string,+ trigger: import('../types').NodeLoadTrigger+ ) => {+ nodeId: string+ trigger: import('../types').NodeLoadTrigger+ } // traceViewLogic+ loadTraceSuccess: (+ trace: import('../../../generated/api.schemas').TraceApi,+ payload?: any+ ) => {+ payload?: any+ trace: import('../../../generated/api.schemas').TraceApi+ } // traceViewLogic+ prefetchNode: (id: string) => {+ id: string+ }selectAndShowSpans: (id: string) => {id: string}@@ -99,8 +118,18 @@ export interface traceViewAdapterLogicActions {export interface traceViewAdapterLogicMeta {key: string__keaTypeGenInternalSelectorTypes: {- selectedNodeId: (event: LLMTrace | LLMTraceEvent | null, traceId: string) => string | null- selectedTreeNode: (tree: TraceNodeApi[], selectedNodeId: string | null) => TraceNodeApi | null+ selectedNodeId: (+ eventId: string | null,+ initialTab: string | null,+ tree: TraceNodeApi[],+ status: TraceViewStatus,+ defaultNodeId: string,+ nodeIdsByAlias: Record<string, string>,+ traceId: string+ ) => string+ selectedTreeNode: (tree: TraceNodeApi[], selectedNodeId: string) => TraceNodeApi | null+ selectedNodeLoad: (selectedNodeId: string, nodes: Record<string, NodeLoad>) => NodeLoad+ threadNodeLoad: (threadNodeIds: string[], nodes: Record<string, NodeLoad>) => NodeLoad | nullbackLink: (searchParams: Record<string, any>) => LabeledLinkheader: (traceName: string,@@ -112,26 +141,27 @@ export interface traceViewAdapterLogicMeta {searchParams: Record<string, any>) => TraceHeaderPropsdetailData: (- trace: LLMTrace | undefined,- event: LLMTrace | LLMTraceEvent | null,- tree: TraceNodeApi[],selectedTreeNode: TraceNodeApi | null,- aiDataCache: Record<string, AIData | null>,+ selectedNodeLoad: NodeLoad,+ tree: TraceNodeApi[],generationEvaluationRuns: EvaluationRun[],generationEvaluationRunsLoading: boolean,evaluations: EvaluationConfig[],detectorEvaluationIds: string[],evaluationsSettled: boolean,currentTeamId: number | null,- personLabel: string | null+ personLabel: string | null,+ createdAt: string | null,+ sessionId: string | null) => NodeDetailData | nullthread: (- trace: LLMTrace | undefined,- aiDataCache: Record<string, AIData | null>,- currentTeamId: number | null+ status: TraceViewStatus,+ threadNodeLoad: NodeLoad | null,+ createdAt: string | null,+ currentTeamId: number | null,+ traceId: string) => ConversationState- canViewInThread: (selectedNodeId: string | null, thread: ConversationState, traceId: string) => boolean- heavyDataLookups: (trace: LLMTrace | undefined, event: LLMTrace | LLMTraceEvent | null) => AIDataLookup[]+ canViewInThread: (selectedNodeId: string, threadNodeIds: string[], traceId: string) => boolean}}@@ -142,6 +172,10 @@ export type traceViewAdapterLogicType = MakeLogicType<traceViewAdapterLogicMeta>+const LOADING: NodeLoad = { status: 'loading' }+// Skimming the tree with the pointer must not start a read for every row it crosses.+const PREFETCH_DELAY_MS = 75+export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([path((key) => ['products', 'ai_observability', 'frontend', 'redesign', 'trace', 'traceViewAdapterLogic', key]),props({} as TraceViewAdapterLogicProps),@@ -149,18 +183,24 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([connect((props: TraceViewAdapterLogicProps) => ({values: [traceViewLogic({ traceId: props.traceId, timestampHint: props.timestampHint }),- ['status', 'errorMessage', 'tree', 'summary', 'timeline', 'traceName', 'traceHasError', 'personLabel'],+ [+ 'status',+ 'errorMessage',+ 'tree',+ 'summary',+ 'timeline',+ 'traceName',+ 'traceHasError',+ 'personLabel',+ 'nodes',+ 'threadNodeIds',+ 'createdAt',+ 'sessionId',+ 'defaultNodeId',+ 'nodeIdsByAlias',+ ],aiObservabilityTraceLogic,- ['olderTraceId', 'olderTimestamp', 'newerTraceId', 'newerTimestamp'],- aiObservabilityTraceDataLogic({- traceId: props.traceId,- query: props.query,- cachedResults: null,- searchQuery: '',- }),- ['trace', 'event'],- aiObservabilityAIDataLogic,- ['aiDataCache'],+ ['eventId', 'initialTab', 'olderTraceId', 'olderTimestamp', 'newerTraceId', 'newerTimestamp'],generationEvaluationRunsLogic({ traceId: props.traceId }),['generationEvaluationRuns', 'generationEvaluationRunsLoading'],teamLogic,@@ -170,7 +210,12 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([router,['searchParams'],],- actions: [aiObservabilityTraceLogic, ['setEventId'], aiObservabilityAIDataLogic, ['ensureAIDataLoaded']],+ actions: [+ aiObservabilityTraceLogic,+ ['setEventId', 'loadNeighbors'],+ traceViewLogic({ traceId: props.traceId, timestampHint: props.timestampHint }),+ ['loadNode', 'loadTraceSuccess'],+ ],})),actions({setMode: (mode: TraceMode) => ({ mode }),@@ -178,6 +223,7 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([selectNode: (id: string) => ({ id }),selectAndShowSpans: (id: string) => ({ id }),viewInThread: true,+ prefetchNode: (id: string) => ({ id }),}),reducers({mode: [@@ -192,14 +238,42 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([}),selectors({selectedNodeId: [- (s, p) => [s.event, p.traceId],- (event: LLMTrace | LLMTraceEvent | null, traceId: string): string | null =>- event ? (isLLMEvent(event) ? event.id : traceId) : null,+ (s, p) => [s.eventId, s.initialTab, s.tree, s.status, s.defaultNodeId, s.nodeIdsByAlias, p.traceId],+ (+ eventId: string | null,+ initialTab: string | null,+ tree: TraceNodeApi[],+ status: TraceViewStatus,+ defaultNodeId: string,+ nodeIdsByAlias: Record<string, string>,+ traceId: string+ ): string => {+ if (status !== 'ready') {+ return eventId ?? traceId+ }+ if (!eventId) {+ // Trace-level links from clusters and sessions ask for the trace itself with tab=summary.+ return initialTab === 'summary' ? traceId : defaultNodeId+ }+ if (findTreeNode(tree, eventId)) {+ return eventId+ }+ return nodeIdsByAlias[eventId] ?? traceId+ },],selectedTreeNode: [(s) => [s.tree, s.selectedNodeId],- (tree: TraceNodeApi[], selectedNodeId: string | null): TraceNodeApi | null =>- selectedNodeId ? findTreeNode(tree, selectedNodeId) : null,+ (tree: TraceNodeApi[], selectedNodeId: string): TraceNodeApi | null => findTreeNode(tree, selectedNodeId),+ ],+ // Each consumer reads its own node load, so a prefetch of another node does not rebuild its heavy messages.+ selectedNodeLoad: [+ (s) => [s.selectedNodeId, s.nodes],+ (selectedNodeId: string, nodes: Record<string, NodeLoad>): NodeLoad => nodes[selectedNodeId] ?? LOADING,+ ],+ threadNodeLoad: [+ (s) => [s.threadNodeIds, s.nodes],+ (threadNodeIds: string[], nodes: Record<string, NodeLoad>): NodeLoad | null =>+ threadNodeIds[0] ? (nodes[threadNodeIds[0]] ?? LOADING) : null,],backLink: [(s) => [s.searchParams],@@ -232,11 +306,9 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([],detailData: [(s) => [- s.trace,- s.event,- s.tree,s.selectedTreeNode,- s.aiDataCache,+ s.selectedNodeLoad,+ s.tree,s.generationEvaluationRuns,s.generationEvaluationRunsLoading,s.evaluations,@@ -244,28 +316,28 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([s.evaluationsSettled,s.currentTeamId,s.personLabel,+ s.createdAt,+ s.sessionId,],(- trace: LLMTrace | undefined,- event: LLMTrace | LLMTraceEvent | null,- tree: TraceNodeApi[],node: TraceNodeApi | null,- cache: Record<string, AIData | null>,+ load: NodeLoad,+ tree: TraceNodeApi[],evalRuns: EvaluationRun[],evalRunsLoading: boolean,evaluations: EvaluationConfig[],detectorEvaluationIds: string[],evaluationsSettled: boolean,teamId: number | null,- person: string | null+ person: string | null,+ createdAt: string | null,+ sessionId: string | null): NodeDetailData | null =>- trace && event && node+ node && createdAt? toNodeDetail({- trace,- event,- tree,node,- cache,+ load,+ tree,evalRuns,evalRunsLoading,evaluations,@@ -273,62 +345,50 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([evaluationsSettled,teamId,person,+ trace: { createdAt, sessionId },}): null,],thread: [- (s) => [s.trace, s.aiDataCache, s.currentTeamId],+ (s, p) => [s.status, s.threadNodeLoad, s.createdAt, s.currentTeamId, p.traceId],(- trace: LLMTrace | undefined,- cache: Record<string, AIData | null>,- teamId: number | null- ): ConversationState => (trace ? toThread(trace, cache, teamId) : { status: 'loading' }),- ],- canViewInThread: [- (s, p) => [s.selectedNodeId, s.thread, p.traceId],- (selectedNodeId: string | null, thread: ConversationState, traceId: string): boolean => {- if (!selectedNodeId) {- return false- }- if (selectedNodeId === traceId) {- return true+ status: TraceViewStatus,+ load: NodeLoad | null,+ createdAt: string | null,+ teamId: number | null,+ traceId: string+ ): ConversationState => {+ if (status !== 'ready' || !createdAt) {+ return { status: 'loading' }}- const turnMessages = thread.status === 'ready' ? (thread.turns[0]?.messages ?? []) : []- return turnMessages.some((message) => message.sourceNodeId === selectedNodeId)+ return toThread({ traceId, createdAt, load, teamId })},],- heavyDataLookups: [- (s) => [s.trace, s.event],- (trace: LLMTrace | undefined, event: LLMTrace | LLMTraceEvent | null): AIDataLookup[] => {- if (!trace) {- return []- }- const candidates = [event && isLLMEvent(event) ? event : null, pickUserVisibleTurn(trace) ?? null]- return candidates- .map((candidate) => (candidate ? heavyDataLookup(candidate, trace.id) : null))- .filter((lookup): lookup is AIDataLookup => lookup !== null)- },+ canViewInThread: [+ (s, p) => [s.selectedNodeId, s.threadNodeIds, p.traceId],+ (selectedNodeId: string, threadNodeIds: string[], traceId: string): boolean =>+ selectedNodeId === traceId || threadNodeIds.includes(selectedNodeId),],}),- listeners(({ actions }) => ({- selectNode: ({ id }) => actions.setEventId(id),- selectAndShowSpans: ({ id }) => actions.setEventId(id),- })),- subscriptions(({ actions }) => ({- heavyDataLookups: (lookups: AIDataLookup[]) => {- if (lookups.length > 0) {- actions.ensureAIDataLoaded(lookups)- }- },- })),- afterMount(() => {- // The legacy scene writes a `search` param into shared trace links. This view has no- // search UI, so without clearing it the tree silently filters down to whatever the- // stale query matched. Removing only that param keeps every other permalink param, and- // the legacy trace logic reads the new URL and clears its search query.- const { search, ...searchParams } = router.values.searchParams- if (search !== undefined) {- router.actions.replace(router.values.location.pathname, searchParams, router.values.hashParams)+ listeners(({ actions, props }) => {+ // The click's read starts before the selection moves, so the selectedNodeId subscription's navigation read+ // for the same id is deduped and the load event reports a click. Selecting the node that is already+ // selected changes no value and the subscription does not fire, so this read also retries a failed node.+ const select = ({ id }: { id: string }): void => {+ actions.loadNode(id, 'selection')+ actions.setEventId(id)+ }+ return {+ selectNode: select,+ selectAndShowSpans: select,+ prefetchNode: async ({ id }, breakpoint) => {+ await breakpoint(PREFETCH_DELAY_MS)+ actions.loadNode(id, 'prefetch')+ },+ loadTraceSuccess: ({ trace }) => actions.loadNeighbors(props.traceId, trace.createdAt),}}),+ subscriptions(({ actions }) => ({+ selectedNodeId: (selectedNodeId: string) => actions.loadNode(selectedNodeId, 'navigation'),+ })),])diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsxindex af38a59a37bf..e4b290fe671b 100644--- a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx@@ -62,7 +62,20 @@ export const LoadingContent: Story = {parameters: { testOptions: { waitForLoadersToDisappear: false } },}export const ContentLoadError: Story = {- args: { ...base, content: { kind: 'error', message: 'This step could not be loaded. Try again later.' } },+ args: { ...base, content: { kind: 'error', message: 'This step could not be loaded. Select it again to retry.' } },+}+export const ContentNotFound: Story = {+ args: {+ ...base,+ content: {+ kind: 'error',+ message: 'This step could not be found. It may have been deleted, or it is outside the retention period.',+ },+ },+}+export const RawTabWhileLoading: Story = {+ args: { ...base, content: { kind: 'loading' }, initialTab: 'raw' },+ parameters: { testOptions: { waitForLoadersToDisappear: false } },}export const WithError: Story = {args: {diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsxindex 1a20ed6c267b..f0cb37a468ac 100644--- a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx@@ -1,7 +1,8 @@-import { LemonTabs } from '@posthog/lemon-ui'+import { LemonSkeleton, LemonTabs } from '@posthog/lemon-ui'import type { TraceNodeApi } from '../../../generated/api.schemas'import { EvalsState, NodeContent, NodeDetailTab, NodeProperties } from '../types'+import { ErrorCallout } from './ErrorCallout'import { EvalResultList } from './EvalResultList'import { NodeDetailHeader } from './NodeDetailHeader'import { NodeMessagesTab } from './NodeMessagesTab'@@ -16,7 +17,7 @@ export interface NodeDetailProps {error: string | nullproperties: NodePropertiesevals: EvalsState- raw: Record<string, unknown>+ raw: Record<string, unknown> | nullonViewInThread: (() => void) | nullonSelectNode: (nodeId: string) => void}@@ -59,7 +60,14 @@ export function NodeDetail(props: NodeDetailProps): JSX.Element {key: 'raw',label: 'Raw','data-attr': 'trace-view-detail-tab-raw',- content: <NodeRawTab raw={props.raw} />,+ content:+ props.content.kind === 'loading' ? (+ <LemonSkeleton repeat={3} className="h-16" />+ ) : props.content.kind === 'error' ? (+ <ErrorCallout message={props.content.message} />+ ) : (+ <NodeRawTab raw={props.raw} />+ ),},]}/>diff --git a/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx b/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsxindex e654ad620e21..b64cda373e75 100644--- a/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx@@ -17,7 +17,7 @@ export interface NodePropertyListProps {export function NodePropertyList({ node, properties }: NodePropertyListProps): JSX.Element {const { stats } = node- const time = (+ const time = properties.timestamp ? (<TZLabeltime={properties.timestamp}timestampStyle="absolute"@@ -26,7 +26,7 @@ export function NodePropertyList({ node, properties }: NodePropertyListProps): JshowSecondsclassName="font-mono"/>- )+ ) : nullconst tokens = formatTokenCounts(stats.inputTokens, stats.outputTokens) ?? UNKNOWN_VALUEconst cache = formatCacheTokens(stats.cacheReadTokens, stats.cacheWriteTokens)const latency = stats.latencyMs !== null ? formatLatencyMs(stats.latencyMs) : UNKNOWN_VALUEdiff --git a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsxindex 491dac715328..ba1d62bc22df 100644--- a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx@@ -17,3 +17,5 @@ export const Default: StoryObj<typeof NodeRawTab> = {},},}++export const NoTraceEvent: StoryObj<typeof NodeRawTab> = { args: { raw: null } }diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsxindex 2ccb3f7ea15a..8ca6184ea88b 100644--- a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx@@ -1,10 +1,18 @@import { JSONViewer } from 'lib/components/JSONViewer'export interface NodeRawTabProps {- raw: Record<string, unknown>+ raw: Record<string, unknown> | null}export function NodeRawTab({ raw }: NodeRawTabProps): JSX.Element {+ if (!raw) {+ return (+ <p className="m-0 text-secondary">+ This trace has no event of its own, so there is no raw event to show. Select a step to see its raw+ event.+ </p>+ )+ }return (<div className="overflow-auto rounded border border-primary bg-surface-primary p-2"><JSONViewer src={raw} name={null} collapsed={2} sortKeys />diff --git a/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsxindex 18bc8eba9916..e367382fd49c 100644--- a/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx@@ -25,6 +25,15 @@ export const Loading: Story = {decorators: [withWidth(720)],parameters: { testOptions: { waitForLoadersToDisappear: false } },}+export const LoadError: Story = {+ args: {+ conversation: {+ status: 'error',+ message: 'The conversation could not be loaded. Reload the page to try again.',+ },+ },+ decorators: [withWidth(720)],+}export const Empty: Story = { args: ready([{ ...FIXTURE_TURN, messages: [] }]) }export const SystemOnly: Story = { args: ready([{ ...FIXTURE_TURN, messages: [FIXTURE_GENERATION_MESSAGES[0]] }]) }export const ErrorWithoutMessages: Story = {diff --git a/products/ai_observability/frontend/redesign/trace/components/Thread.tsx b/products/ai_observability/frontend/redesign/trace/components/Thread.tsxindex cc385f0c0070..a4ffd8fa3dc7 100644--- a/products/ai_observability/frontend/redesign/trace/components/Thread.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/Thread.tsx@@ -2,6 +2,7 @@ import { LemonSkeleton } from '@posthog/lemon-ui'import { ConversationState } from '../types'import { conversationalMessages } from './conversationalMessages'+import { ErrorCallout } from './ErrorCallout'import { ThreadTurn } from './ThreadTurn'export interface ThreadProps {@@ -19,6 +20,9 @@ export function Thread({ conversation, onSelectMessage }: ThreadProps): JSX.Elem</div>)}+ if (conversation.status === 'error') {+ return <ErrorCallout message={conversation.message} />+ }const { turns, activeTurnId } = conversationif (turns.every((turn) => conversationalMessages(turn.messages).length === 0 && !turn.error)) {return (diff --git a/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx b/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsxindex 5174a14f069e..fbe16360a2cd 100644--- a/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx@@ -19,15 +19,18 @@ export interface TimelineRowProps {ticks: TimelineTick[]isSelected: booleanonSelect: () => void+ onPrefetch: () => void}-export function TimelineRow({ row, totalMs, ticks, isSelected, onSelect }: TimelineRowProps): JSX.Element {+export function TimelineRow({ row, totalMs, ticks, isSelected, onSelect, onPrefetch }: TimelineRowProps): JSX.Element {const { leftPercent, widthPercent } = timelineBarGeometry(row.startMs, row.durationMs ?? 0, totalMs)const barColors = row.hasError ? ERROR_BAR_COLORS : NODE_KIND_COLORS[row.kind]return (<buttontype="button"onClick={onSelect}+ onMouseEnter={onPrefetch}+ onFocus={onPrefetch}data-attr="trace-view-timeline-row"className={cn('grid w-full items-center border-b border-primary text-left hover:bg-fill-button-tertiary-hover',diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsxindex 4b671731261b..dc51b5275a82 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx@@ -19,6 +19,7 @@ const meta: Meta<typeof TraceSplitView> = {tree: FIXTURE_TREE,selectedNodeId: generation.id,onSelectNode: () => {},+ onPrefetchNode: () => {},detail: {node: generation,tab: 'messages',diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsxindex 66287768f7ba..8df6d36ee2d2 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx@@ -6,15 +6,27 @@ export interface TraceSplitViewProps {tree: TraceNodeApi[]selectedNodeId: string | nullonSelectNode: (id: string) => void+ onPrefetchNode: (id: string) => voiddetail: Omit<NodeDetailProps, 'onSelectNode'> | null}-export function TraceSplitView({ tree, selectedNodeId, onSelectNode, detail }: TraceSplitViewProps): JSX.Element {+export function TraceSplitView({+ tree,+ selectedNodeId,+ onSelectNode,+ onPrefetchNode,+ detail,+}: TraceSplitViewProps): JSX.Element {return (<div className="@container"><div className="flex flex-col gap-4 @3xl:flex-row @3xl:items-start"><aside className="w-full shrink-0 @3xl:w-72">- <TraceTree nodes={tree} selectedNodeId={selectedNodeId} onSelectNode={onSelectNode} />+ <TraceTree+ nodes={tree}+ selectedNodeId={selectedNodeId}+ onSelectNode={onSelectNode}+ onPrefetchNode={onPrefetchNode}+ /></aside><div className="min-w-0 flex-1 @3xl:sticky @3xl:top-[var(--scene-title-section-height,50px)] @3xl:max-h-[calc(100vh-var(--scene-title-section-height,50px))] @3xl:overflow-y-auto">{detail ? (diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsxindex 682651b3daea..15fd6c4be9c3 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx@@ -9,7 +9,13 @@ import { TraceTimeline } from './TraceTimeline'const meta: Meta<typeof TraceTimeline> = {title: 'Scenes-App/AI observability/Trace view/Trace timeline',component: TraceTimeline,- args: { rows: FIXTURE_TIMELINE_ROWS, totalMs: 2310, selectedNodeId: 'gen-answer', onSelectNode: () => {} },+ args: {+ rows: FIXTURE_TIMELINE_ROWS,+ totalMs: 2310,+ selectedNodeId: 'gen-answer',+ onSelectNode: () => {},+ onPrefetchNode: () => {},+ },}export default metadiff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsxindex 287d17540b7c..24ac221628ba 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx@@ -10,9 +10,16 @@ export interface TraceTimelineProps {totalMs: numberselectedNodeId: string | nullonSelectNode: (id: string) => void+ onPrefetchNode: (id: string) => void}-export function TraceTimeline({ rows, totalMs, selectedNodeId, onSelectNode }: TraceTimelineProps): JSX.Element {+export function TraceTimeline({+ rows,+ totalMs,+ selectedNodeId,+ onSelectNode,+ onPrefetchNode,+}: TraceTimelineProps): JSX.Element {if (rows.length === 0) {return <p className="m-0 text-secondary">This trace has no timed steps.</p>}@@ -31,6 +38,7 @@ export function TraceTimeline({ rows, totalMs, selectedNodeId, onSelectNode }: Tticks={ticks}isSelected={row.id === selectedNodeId}onSelect={() => onSelectNode(row.id)}+ onPrefetch={() => onPrefetchNode(row.id)}/>))}</div>diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsxindex 6f75424c0972..80657ebe6ef9 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx@@ -14,7 +14,7 @@ function Stateful({initialSelectedId?: string}): JSX.Element {const [selected, setSelected] = useState<string | null>(initialSelectedId)- return <TraceTree nodes={nodes} selectedNodeId={selected} onSelectNode={setSelected} />+ return <TraceTree nodes={nodes} selectedNodeId={selected} onSelectNode={setSelected} onPrefetchNode={() => {}} />}const meta: Meta<typeof Stateful> = {diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsxindex b66a6afb1817..fbee84640593 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx@@ -5,9 +5,10 @@ export interface TraceTreeProps {nodes: TraceNodeApi[]selectedNodeId: string | nullonSelectNode: (id: string) => void+ onPrefetchNode: (id: string) => void}-export function TraceTree({ nodes, selectedNodeId, onSelectNode }: TraceTreeProps): JSX.Element {+export function TraceTree({ nodes, selectedNodeId, onSelectNode, onPrefetchNode }: TraceTreeProps): JSX.Element {return (<ul aria-label="Trace steps" className="m-0 list-none rounded border border-primary bg-surface-primary p-1">{nodes.map((node) => (@@ -17,6 +18,7 @@ export function TraceTree({ nodes, selectedNodeId, onSelectNode }: TraceTreePropdepth={0}selectedNodeId={selectedNodeId}onSelectNode={onSelectNode}+ onPrefetchNode={onPrefetchNode}/>))}</ul>diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsxindex f6ae347fcea4..6f3bfc939c50 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx@@ -11,15 +11,24 @@ export interface TraceTreeRowProps {depth: numberselectedNodeId: string | nullonSelectNode: (id: string) => void+ onPrefetchNode: (id: string) => void}-export function TraceTreeRow({ node, depth, selectedNodeId, onSelectNode }: TraceTreeRowProps): JSX.Element {+export function TraceTreeRow({+ node,+ depth,+ selectedNodeId,+ onSelectNode,+ onPrefetchNode,+}: TraceTreeRowProps): JSX.Element {const isSelected = node.id === selectedNodeIdreturn (<li><buttontype="button"onClick={() => onSelectNode(node.id)}+ onMouseEnter={() => onPrefetchNode(node.id)}+ onFocus={() => onPrefetchNode(node.id)}aria-current={isSelected ? 'true' : undefined}data-attr="trace-view-tree-node"className={cn(@@ -53,6 +62,7 @@ export function TraceTreeRow({ node, depth, selectedNodeId, onSelectNode }: Tracdepth={depth + 1}selectedNodeId={selectedNodeId}onSelectNode={onSelectNode}+ onPrefetchNode={onPrefetchNode}/>))}</ul>diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsxindex d20ce9d61d66..29b18ad5498f 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx@@ -69,6 +69,7 @@ function Playground({ fixture, initialMode, initialNodeId }: PlaygroundProps): Jtree={fixture.tree}selectedNodeId={selectedNodeId}onSelectNode={setSelectedNodeId}+ onPrefetchNode={() => {}}onSelectFromView={selectAndShowSpans}detail={{...fixture.details[node.id],diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceView.tsxindex 935f0cbbf42a..c00c1c14554a 100644--- a/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx+++ b/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx@@ -18,6 +18,7 @@ export interface TraceViewReadyProps {tree: TraceNodeApi[]selectedNodeId: string | nullonSelectNode: (id: string) => void+ onPrefetchNode: (id: string) => voidonSelectFromView: (id: string) => voiddetail: Omit<NodeDetailProps, 'onSelectNode'> | nullthread: ConversationState@@ -46,6 +47,7 @@ export function TraceView(props: TraceViewProps): JSX.Element {tree={props.tree}selectedNodeId={props.selectedNodeId}onSelectNode={props.onSelectNode}+ onPrefetchNode={props.onPrefetchNode}detail={props.detail}/>) : props.mode === 'thread' ? (@@ -56,6 +58,7 @@ export function TraceView(props: TraceViewProps): JSX.Element {totalMs={props.timeline.totalMs}selectedNodeId={props.selectedNodeId}onSelectNode={props.onSelectFromView}+ onPrefetchNode={props.onPrefetchNode}/>)}</div>diff --git a/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts b/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.tsindex bae776039574..f33d88d23bcb 100644--- a/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts+++ b/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts@@ -1,23 +1,67 @@import { expectLogic } from 'kea-test-utils'+import posthog from 'posthog-js'import { resumeKeaLoadersErrors, silenceKeaLoadersErrors } from '~/initKea'import { useMocks } from '~/mocks/jest'import { initKeaTests } from '~/test/init'-import { makeTraceResource } from './adapter/testFixtures'+import type { TraceTimelineRowApi } from '../../generated/api.schemas'+import { decodeIdSegment, makeNodeDetail, makeTraceResource } from './adapter/testFixtures'import { traceViewLogic } from './traceViewLogic'const TRACE_URL = '/api/projects/:team_id/ai_observability/traces/:id/'+const NODE_URL = '/api/projects/:team_id/ai_observability/traces/:id/nodes/:node_id/'+const EXPIRED_ROW: TraceTimelineRowApi = {+ id: 'expired-1',+ kind: 'span',+ name: 'expired-1',+ depth: 0,+ startMs: 0,+ durationMs: null,+ hasError: false,+}++function deferred(): { promise: Promise<void>; resolve: () => void } {+ let resolve = (): void => {}+ const promise = new Promise<void>((done) => {+ resolve = done+ })+ return { promise, resolve }+}describe('traceViewLogic', () => {let requestedHint: string | null = nulllet requestedPath: string | null = null+ let nodeRequests: string[] = []+ let nodeHints: (string | null)[] = []+ let nodeStatus = 200+ let nodeGate: Promise<void> = Promise.resolve()+ let firstNodeAnswer = deferred()beforeEach(() => {requestedHint = nullrequestedPath = null+ nodeRequests = []+ nodeHints = []+ nodeStatus = 200+ nodeGate = Promise.resolve()+ firstNodeAnswer = deferred()useMocks({get: {+ // `expired-*` ids stand for nodes of a trace past the ai_events retention: the backend only finds+ // them when the read carries a timestamp hint.+ [NODE_URL]: async ({ request, params }) => {+ const nodeId = decodeIdSegment(String(params.node_id))+ const hint = new URL(request.url).searchParams.get('timestamp_hint')+ nodeRequests.push(nodeId)+ nodeHints.push(hint)+ await nodeGate+ firstNodeAnswer.resolve()+ if (nodeId.startsWith('expired-') && !hint) {+ return [404, { detail: 'Node not found.' }]+ }+ return nodeStatus === 200 ? [200, makeNodeDetail({ id: nodeId })] : [nodeStatus, { detail: 'nope' }]+ },[TRACE_URL]: ({ request }) => {const url = new URL(request.url)requestedHint = url.searchParams.get('timestamp_hint')@@ -29,7 +73,17 @@ describe('traceViewLogic', () => {initKeaTests()})- afterEach(resumeKeaLoadersErrors)+ afterEach(() => {+ resumeKeaLoadersErrors()+ jest.restoreAllMocks()+ })++ async function mountedLogic(): Promise<ReturnType<typeof traceViewLogic.build>> {+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: null })+ logic.mount()+ await expectLogic(logic).toFinishAllListeners()+ return logic+ }it('loads the trace by its encoded id with the link timestamp as the hint and derives the summary', async () => {const logic = traceViewLogic({ traceId: 'a/b', timestampHint: '2026-09-01T10:15:00Z' })@@ -59,4 +113,231 @@ describe('traceViewLogic', () => {.toFinishAllListeners().toMatchValues({ status: 'error', errorMessage: expectedMessage })})++ it('loads the thread nodes once the trace arrives', async () => {+ const logic = await mountedLogic()++ expect(nodeRequests).toEqual(['gen-2'])+ expect(logic.values.nodes['gen-2']).toMatchObject({ status: 'ready' })+ })++ it('reads each node once, however many times it is asked for', async () => {+ const logic = await mountedLogic()++ logic.actions.loadNode('span-1', 'prefetch')+ logic.actions.loadNode('span-1', 'selection')+ await expectLogic(logic).toFinishAllListeners()+ logic.actions.loadNode('span-1', 'selection')+ await expectLogic(logic).toFinishAllListeners()++ expect(nodeRequests.filter((id) => id === 'span-1')).toHaveLength(1)+ })++ it.each([+ ['a later prefetch once the first one is answered', 'prefetch', 200],+ ['a later prefetch once the first one fails', 'prefetch', 500],+ ['a selection while the first one is in flight', 'selection', 200],+ ] as const)(+ 'drops a prefetch while another is in flight, then reads the node for %s',+ async (_description, trigger, firstStatus) => {+ const logic = await mountedLogic()+ const firstPrefetch = deferred()+ nodeGate = firstPrefetch.promise+ nodeStatus = firstStatus+ nodeRequests = []++ logic.actions.loadNode('span-1', 'prefetch')+ logic.actions.loadNode('gen-1', 'prefetch')+ expect(logic.values.nodes['gen-1']).toBeUndefined()++ if (trigger === 'prefetch') {+ firstPrefetch.resolve()+ await expectLogic(logic).toFinishAllListeners()+ }+ logic.actions.loadNode('gen-1', trigger)+ firstPrefetch.resolve()+ await expectLogic(logic).toFinishAllListeners()++ expect([...nodeRequests].sort()).toEqual(['gen-1', 'span-1'])+ }+ )++ it.each([+ [404, 'not_found'],+ [500, 'failed'],+ ])('a node read answered with %s fails as %s', async (status, failure) => {+ const logic = await mountedLogic()+ nodeStatus = status++ logic.actions.loadNode('span-1', 'selection')+ await expectLogic(logic).toFinishAllListeners()++ expect(logic.values.nodes['span-1']).toEqual({ status: 'error', failure })+ })++ it.each(['selection', 'navigation'] as const)(+ 'retries a failed node on a %s but not on a prefetch',+ async (trigger) => {+ const logic = await mountedLogic()+ nodeStatus = 500+ logic.actions.loadNode('span-1', trigger)+ await expectLogic(logic).toFinishAllListeners()+ nodeStatus = 200++ logic.actions.loadNode('span-1', 'prefetch')+ await expectLogic(logic).toFinishAllListeners()+ expect(logic.values.nodes['span-1']).toMatchObject({ status: 'error' })++ logic.actions.loadNode('span-1', trigger)+ await expectLogic(logic).toFinishAllListeners()+ expect(logic.values.nodes['span-1']).toMatchObject({ status: 'ready' })+ }+ )++ it('times a retried read from the click that retries it', async () => {+ const logic = await mountedLogic()+ const capture = jest.spyOn(posthog, 'capture')+ let now = 1000+ jest.spyOn(performance, 'now').mockImplementation(() => now)+ nodeStatus = 500+ logic.actions.loadNode('span-1', 'selection')+ await expectLogic(logic).toFinishAllListeners()++ now = 5000+ nodeStatus = 200+ logic.actions.loadNode('span-1', 'selection')+ await expectLogic(logic).toFinishAllListeners()++ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: 0,+ trigger: 'selection',+ waited_ms: 0,+ })+ })++ it('reports how long the reads took and how long a click waited', async () => {+ const capture = jest.spyOn(posthog, 'capture')+ const logic = await mountedLogic()++ logic.actions.loadNode('span-1', 'prefetch')+ logic.actions.loadNode('span-1', 'selection')+ logic.actions.loadNode('gen-1', 'navigation')+ await expectLogic(logic).toFinishAllListeners()++ expect(capture).toHaveBeenCalledWith('llma trace view loaded', {+ trace_load_ms: expect.any(Number),+ node_count: 0,+ })+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: expect.any(Number),+ trigger: 'thread',+ waited_ms: null,+ })+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: expect.any(Number),+ trigger: 'prefetch',+ waited_ms: expect.any(Number),+ })+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: expect.any(Number),+ trigger: 'navigation',+ waited_ms: null,+ })+ })++ it.each([+ ['misses', 'expired-1'],+ ['succeeds', 'closed-1'],+ ])('drops a read that %s after the view is closed, even once the trace is open again', async (_, nodeId) => {+ useMocks({ get: { [TRACE_URL]: () => [200, makeTraceResource({ timeline: [EXPIRED_ROW] })] } })+ const heldNodeReads = deferred()+ nodeGate = heldNodeReads.promise+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: null })+ logic.mount()+ logic.actions.loadNode(nodeId, 'selection')+ await expectLogic(logic).toDispatchActions(['loadTraceSuccess'])+ logic.unmount()+ const reopened = traceViewLogic({ traceId: 'trace-1', timestampHint: null })+ reopened.mount()+ await expectLogic(reopened).toDispatchActions(['loadTraceSuccess'])+ heldNodeReads.resolve()++ await expectLogic(reopened).toFinishAllListeners()++ expect(nodeRequests.filter((id) => id === nodeId)).toHaveLength(1)+ expect(reopened.values.nodes[nodeId]).toBeUndefined()+ })++ describe('nodes of a trace past the ai_events retention', () => {+ it.each([+ ['trace', 'expired-1', [null, '2026-09-01T10:15:00Z'], 'ready'],+ ['node', 'expired-1', [null, '2026-09-01T10:15:00Z'], 'ready'],+ ['trace', 'expired-9', [null], 'error'],+ ['node', 'expired-9', [null], 'error'],+ ])(+ 'when the %s response comes first, an early read of %s is sent with %j and ends as %s',+ async (firstResponse, nodeId, expectedHints, expectedStatus) => {+ const heldNodeReads = deferred()+ if (firstResponse === 'trace') {+ nodeGate = heldNodeReads.promise+ }+ useMocks({+ get: {+ [TRACE_URL]: async () => {+ if (firstResponse === 'node') {+ await firstNodeAnswer.promise+ }+ return [200, makeTraceResource({ timeline: [EXPIRED_ROW] })]+ },+ },+ })+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: '2026-09-01T10:15:00Z' })+ logic.mount()+ logic.actions.loadNode(nodeId, 'selection')+ if (firstResponse === 'trace') {+ await expectLogic(logic).toDispatchActions(['loadTraceSuccess'])+ heldNodeReads.resolve()+ }++ await expectLogic(logic).toFinishAllListeners()++ expect(logic.values.nodes[nodeId]).toMatchObject({ status: expectedStatus })+ expect(nodeHints.filter((_, index) => nodeRequests[index] === nodeId)).toEqual(expectedHints)+ }+ )++ it('times a reread from the first request to its answer', async () => {+ const capture = jest.spyOn(posthog, 'capture')+ let now = 1000+ jest.spyOn(performance, 'now').mockImplementation(() => now)+ const heldTrace = deferred()+ useMocks({+ get: {+ [TRACE_URL]: async () => {+ await heldTrace.promise+ return [200, makeTraceResource({ timeline: [EXPIRED_ROW] })]+ },+ },+ })+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: null })+ logic.mount()+ logic.actions.loadNode('expired-1', 'selection')+ await expectLogic(logic).toDispatchActions(['nodeMissedWithoutHint'])++ const heldReread = deferred()+ nodeGate = heldReread.promise+ now = 3000+ heldTrace.resolve()+ await expectLogic(logic).toDispatchActions(['loadTraceSuccess'])+ now = 7000+ heldReread.resolve()+ await expectLogic(logic).toFinishAllListeners()++ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {+ load_ms: 6000,+ trigger: 'selection',+ waited_ms: 6000,+ })+ })+ })})diff --git a/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts b/products/ai_observability/frontend/redesign/trace/traceViewLogic.tsindex a81694700a8c..3607fb69f038 100644--- a/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts+++ b/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts@@ -1,13 +1,15 @@-import { MakeLogicType, afterMount, kea, key, path, props, reducers, selectors } from 'kea'+import { MakeLogicType, actions, afterMount, kea, key, listeners, path, props, reducers, selectors } from 'kea'import { loaders } from 'kea-loaders'+import posthog from 'posthog-js'import { ApiConfig, ApiError } from 'lib/api'import { urls } from 'scenes/urls'-import { aiObservabilityTracesRetrieve } from '../../generated/api'-import type { TraceApi, TraceNodeApi, TraceTimelineRowApi } from '../../generated/api.schemas'+import { aiObservabilityTracesNodesRetrieve, aiObservabilityTracesRetrieve } from '../../generated/api'+import type { TraceApi, TraceNodeApi, TraceNodeDetailApi, TraceTimelineRowApi } from '../../generated/api.schemas'import { TraceSummaryBarProps } from './components/TraceSummaryBar'import { encodeTraceIdSegment } from './traceIdSegment'+import type { LoadFailure, NodeLoad, NodeLoadTrigger } from './types'export interface TraceViewLogicProps {traceId: string@@ -16,15 +18,20 @@ export interface TraceViewLogicProps {export type TraceViewStatus = 'loading' | 'error' | 'ready'-type LoadFailure = 'not_found' | 'failed'-// Generated by kea-typegen. Update if you're an agent, ignore if you're human.export interface traceViewLogicValues {+ createdAt: string | null+ defaultNodeId: stringerrorMessage: stringloadFailure: LoadFailure | null+ nodeIdsByAlias: Record<string, string>+ nodes: Record<string, NodeLoad>+ nodesMissedWithoutHint: Record<string, NodeLoadTrigger>personLabel: string | null+ sessionId: string | nullstatus: TraceViewStatussummary: TraceSummaryBarProps | null+ threadNodeIds: string[]timeline: {rows: TraceTimelineRowApi[]totalMs: number@@ -38,6 +45,27 @@ export interface traceViewLogicValues {// Generated by kea-typegen. Update if you're an agent, ignore if you're human.export interface traceViewLogicActions {+ loadNode: (+ nodeId: string,+ trigger: NodeLoadTrigger+ ) => {+ nodeId: string+ trigger: NodeLoadTrigger+ }+ loadNodeFailure: (+ nodeId: string,+ failure: LoadFailure+ ) => {+ failure: LoadFailure+ nodeId: string+ }+ loadNodeSuccess: (+ nodeId: string,+ node: TraceNodeDetailApi+ ) => {+ node: TraceNodeDetailApi+ nodeId: string+ }loadTrace: () => anyloadTraceFailure: (error: string,@@ -53,6 +81,20 @@ export interface traceViewLogicActions {trace: TraceApipayload?: any}+ nodeMissedWithoutHint: (+ nodeId: string,+ trigger: NodeLoadTrigger+ ) => {+ nodeId: string+ trigger: NodeLoadTrigger+ }+ nodeRequested: (+ nodeId: string,+ trigger: NodeLoadTrigger+ ) => {+ nodeId: string+ trigger: NodeLoadTrigger+ }}// Generated by kea-typegen. Update if you're an agent, ignore if you're human.@@ -70,6 +112,11 @@ export interface traceViewLogicMeta {traceHasError: (trace: TraceApi | null) => booleanpersonLabel: (trace: TraceApi | null) => string | nullsummary: (trace: TraceApi | null) => TraceSummaryBarProps | null+ threadNodeIds: (trace: TraceApi | null) => string[]+ createdAt: (trace: TraceApi | null) => string | null+ sessionId: (trace: TraceApi | null) => string | null+ defaultNodeId: (trace: TraceApi | null, traceId: string) => string+ nodeIdsByAlias: (trace: TraceApi | null) => Record<string, string>}}@@ -80,20 +127,37 @@ export type traceViewLogicType = MakeLogicType<traceViewLogicMeta>+function toLoadFailure(error: unknown): LoadFailure {+ return error instanceof ApiError && error.status === 404 ? 'not_found' : 'failed'+}++function elapsedMs(since: number): number {+ return Math.round(performance.now() - since)+}+export const traceViewLogic = kea<traceViewLogicType>([path((key) => ['products', 'ai_observability', 'frontend', 'redesign', 'trace', 'traceViewLogic', key]),props({} as TraceViewLogicProps),key((props) => props.traceId),- loaders(({ props }) => ({+ actions({+ loadNode: (nodeId: string, trigger: NodeLoadTrigger) => ({ nodeId, trigger }),+ nodeRequested: (nodeId: string, trigger: NodeLoadTrigger) => ({ nodeId, trigger }),+ nodeMissedWithoutHint: (nodeId: string, trigger: NodeLoadTrigger) => ({ nodeId, trigger }),+ loadNodeSuccess: (nodeId: string, node: TraceNodeDetailApi) => ({ nodeId, node }),+ loadNodeFailure: (nodeId: string, failure: LoadFailure) => ({ nodeId, failure }),+ }),+ loaders(({ props, cache }) => ({trace: [null as TraceApi | null,{- loadTrace: async (): Promise<TraceApi> =>- await aiObservabilityTracesRetrieve(+ loadTrace: async (): Promise<TraceApi> => {+ cache.traceRequestedAt = performance.now()+ return await aiObservabilityTracesRetrieve(String(ApiConfig.getCurrentProjectId()),encodeTraceIdSegment(props.traceId),props.timestampHint ? { timestamp_hint: props.timestampHint } : undefined- ),+ )+ },},],})),@@ -102,8 +166,24 @@ export const traceViewLogic = kea<traceViewLogicType>([null as LoadFailure | null,{loadTrace: () => null,- loadTraceFailure: (_, { errorObject }) =>- errorObject instanceof ApiError && errorObject.status === 404 ? 'not_found' : 'failed',+ loadTraceFailure: (_, { errorObject }) => toLoadFailure(errorObject),+ },+ ],+ nodes: [+ {} as Record<string, NodeLoad>,+ {+ nodeRequested: (state, { nodeId }): Record<string, NodeLoad> => ({+ ...state,+ [nodeId]: { status: 'loading' },+ }),+ loadNodeSuccess: (state, { nodeId, node }): Record<string, NodeLoad> => ({+ ...state,+ [nodeId]: { status: 'ready', node },+ }),+ loadNodeFailure: (state, { nodeId, failure }): Record<string, NodeLoad> => ({+ ...state,+ [nodeId]: { status: 'error', failure },+ }),},],}),@@ -145,8 +225,141 @@ export const traceViewLogic = kea<traceViewLogicType>([}: null,],+ threadNodeIds: [(s) => [s.trace], (trace: TraceApi | null): string[] => trace?.threadNodeIds ?? []],+ createdAt: [(s) => [s.trace], (trace: TraceApi | null): string | null => trace?.createdAt ?? null],+ sessionId: [(s) => [s.trace], (trace: TraceApi | null): string | null => trace?.sessionId ?? null],+ defaultNodeId: [+ (s, p) => [s.trace, p.traceId],+ (trace: TraceApi | null, traceId: string): string => trace?.defaultNodeId ?? traceId,+ ],+ nodeIdsByAlias: [+ (s) => [s.trace],+ (trace: TraceApi | null): Record<string, string> => trace?.nodeIdsByAlias ?? {},+ ],+ }),+ listeners(({ actions, values, props, cache }) => {+ const selectedAt = (): Record<string, number> => (cache.selectedAt ??= {})+ const requestedAt = (): Record<string, number> => (cache.requestedAt ??= {})++ const endRead = (nodeId: string): void => {+ delete selectedAt()[nodeId]+ delete requestedAt()[nodeId]+ if (cache.prefetchingNodeId === nodeId) {+ cache.prefetchingNodeId = null+ }+ }++ return {+ loadTraceSuccess: ({ trace }) => {+ posthog.capture('llma trace view loaded', {+ trace_load_ms: elapsedMs(cache.traceRequestedAt),+ node_count: trace.timeline.length,+ })+ for (const nodeId of trace.threadNodeIds) {+ actions.loadNode(nodeId, 'thread')+ }+ },+ loadNode: ({ nodeId, trigger }) => {+ const current = values.nodes[nodeId]+ if (trigger === 'selection' && current?.status !== 'ready') {+ selectedAt()[nodeId] ??= performance.now()+ }+ if (current?.status === 'loading' || current?.status === 'ready') {+ return+ }+ if (current?.status === 'error' && trigger !== 'selection' && trigger !== 'navigation') {+ return+ }+ if (trigger === 'prefetch') {+ // Each read holds one of the organization's query slots, so a slow sweep over the tree must+ // not start one read per row it crosses.+ if (cache.prefetchingNodeId) {+ return+ }+ cache.prefetchingNodeId = nodeId+ }+ actions.nodeRequested(nodeId, trigger)+ },+ nodeRequested: async ({ nodeId, trigger }) => {+ const hint = values.createdAt+ const firstRequestedAt = (requestedAt()[nodeId] ??= performance.now())+ const result = await aiObservabilityTracesNodesRetrieve(+ String(ApiConfig.getCurrentProjectId()),+ encodeTraceIdSegment(props.traceId),+ encodeTraceIdSegment(nodeId),+ hint ? { timestamp_hint: hint } : undefined+ ).then(+ (node: TraceNodeDetailApi) => ({ node }),+ (error: unknown) => ({ failure: toLoadFailure(error) })+ )+ // A read can answer after the view closed, and a reopened view of the trace shares its actions.+ if (cache.disposables.isDisposed) {+ return+ }+ if ('failure' in result) {+ if (result.failure === 'not_found' && !hint) {+ actions.nodeMissedWithoutHint(nodeId, trigger)+ } else {+ actions.loadNodeFailure(nodeId, result.failure)+ }+ return+ }+ const waitedSince = selectedAt()[nodeId]+ const loadMs = elapsedMs(firstRequestedAt)+ const waitedMs = waitedSince === undefined ? null : elapsedMs(waitedSince)+ actions.loadNodeSuccess(nodeId, result.node)+ posthog.capture('llma trace node loaded', { load_ms: loadMs, trigger, waited_ms: waitedMs })+ },+ loadNodeSuccess: ({ nodeId }) => endRead(nodeId),+ loadNodeFailure: ({ nodeId }) => endRead(nodeId),+ }}),afterMount(({ actions }) => {actions.loadTrace()}),+ // Without a hint the backend reads ai_events only, so an early read of a node from a trace past the ai_events+ // retention misses. The node stays loading and is read again once the trace's timestamp is known.+ reducers({+ nodesMissedWithoutHint: [+ {} as Record<string, NodeLoadTrigger>,+ {+ nodeMissedWithoutHint: (state, { nodeId, trigger }): Record<string, NodeLoadTrigger> => ({+ ...state,+ [nodeId]: trigger,+ }),+ nodeRequested: (state, { nodeId }): Record<string, NodeLoadTrigger> => {+ const { [nodeId]: _, ...rest } = state+ return rest+ },+ loadNodeFailure: (state, { nodeId }): Record<string, NodeLoadTrigger> => {+ const { [nodeId]: _, ...rest } = state+ return rest+ },+ },+ ],+ }),+ listeners(({ actions, values }) => {+ // The timeline lists every tree node, so an id outside it is a stale or SDK id that no hint will find.+ const isTraceNode = (trace: TraceApi, nodeId: string): boolean =>+ nodeId === trace.id || trace.timeline.some((row) => row.id === nodeId)++ const rereadMissedNodes = (): void => {+ const { trace } = values+ if (!trace) {+ return+ }+ for (const [nodeId, trigger] of Object.entries(values.nodesMissedWithoutHint)) {+ if (isTraceNode(trace, nodeId)) {+ actions.nodeRequested(nodeId, trigger)+ } else {+ actions.loadNodeFailure(nodeId, 'not_found')+ }+ }+ }++ return {+ loadTraceSuccess: rereadMissedNodes,+ nodeMissedWithoutHint: rereadMissedNodes,+ }+ }),])diff --git a/products/ai_observability/frontend/redesign/trace/types.ts b/products/ai_observability/frontend/redesign/trace/types.tsindex 9956c67ca896..864a6a6271f5 100644--- a/products/ai_observability/frontend/redesign/trace/types.ts+++ b/products/ai_observability/frontend/redesign/trace/types.ts@@ -1,4 +1,4 @@-import type { TraceNodeApi } from '../../generated/api.schemas'+import type { TraceNodeApi, TraceNodeDetailApi } from '../../generated/api.schemas'export type TraceNodeKind = TraceNodeApi['kind']@@ -8,6 +8,19 @@ export type TraceViewChoice = 'new' | 'legacy'export type NodeDetailTab = 'messages' | 'details' | 'evals' | 'raw'+export type LoadFailure = 'not_found' | 'failed'++/**+ * `selection` is a click on a step. `navigation` is a node the view selects without a click: on open, from a+ * link, as the default node, as the root while the trace loads, or from the browser history.+ */+export type NodeLoadTrigger = 'selection' | 'navigation' | 'prefetch' | 'thread'++export type NodeLoad =+ | { status: 'loading' }+ | { status: 'ready'; node: TraceNodeDetailApi }+ | { status: 'error'; failure: LoadFailure }+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool'export type AttachmentMediaType = 'image' | 'audio' | 'video' | 'file'@@ -41,6 +54,7 @@ export interface ConversationTurn {export type ConversationState =| { status: 'loading' }+ | { status: 'error'; message: string }| { status: 'ready'; turns: ConversationTurn[]; activeTurnId: string | null }export type NodeContent =@@ -50,7 +64,7 @@ export type NodeContent =| { kind: 'error'; message: string }export interface NodeProperties {- timestamp: string+ timestamp: string | nullprovider: string | nulltemperature: number | nullsessionId: string | nulldiff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.tsindex 8c39ab1028c3..29dc7ad1688c 100644--- a/services/mcp/src/api/generated.ts+++ b/services/mcp/src/api/generated.ts@@ -114685,6 +114685,8 @@ export namespace Schemas {change: WoWChange | null;}+ export type TraceNodeIdsByAlias = {[key: string]: string};+export interface TracePerson {distinctId: string;label: string;@@ -114742,6 +114744,45 @@ export namespace Schemas {timeline: TraceTimelineRow[];totalMs: number;threadNodeIds: string[];+ defaultNodeId: string;+ nodeIdsByAlias: TraceNodeIdsByAlias;+ }++ export interface TraceNodeMetadata {+ provider: string | null;+ temperature: number | null;+ sessionId: string | null;+ promptName: string | null;+ promptVersion: number | null;+ }++ export interface TraceNodeIOKeys {+ input: string | null;+ output: string | null;+ tools: string | null;+ }++ /**+ * The event's properties as ingested, including its input and output values.+ */+ export type TraceNodeEventProperties = { [key: string]: unknown };++ export interface TraceNodeEvent {+ name: string;+ uuid: string;+ timestamp: string;+ /** The event's properties as ingested, including its input and output values. */+ properties: TraceNodeEventProperties;+ /** Which keys of `properties` hold the node's input, output and tools, or null when it has none. */+ ioKeys: TraceNodeIOKeys;+ }++ export interface TraceNodeDetail {+ id: string;+ kind: TraceNodeKindEnum;+ error: string | null;+ metadata: TraceNodeMetadata;+ event: TraceNodeEvent | null;}export interface TraceReviewCreate {@@ -122939,6 +122980,13 @@ export namespace Schemas {timestamp_hint?: string;};+ export type AiObservabilityTracesNodesRetrieveParams = {+ /**+ * When the trace happened, as carried by links into it. Lets a trace older than the AI events retention load from the shared events table.+ */+ timestamp_hint?: string;+ };+export type AlertsListParams = {/*** Optional. Restrict results to alerts created by the user with this UUID.