Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

feat(experiments): annotate directly from comparison grid (#17990)

marliessophiea9a99bdacd5a
diff --git a/web/src/components/table/peek.tsx b/web/src/components/table/peek.tsx
index f8b8bd9bd8..289b6795d1 100644
--- a/web/src/components/table/peek.tsx
+++ b/web/src/components/table/peek.tsx
@@ -1,3 +1,4 @@
+import { type PeekOpenOptions } from "./peek/hooks/usePeekNavigation";
/* eslint-disable @repo/no-null-render */
import * as SheetPrimitive from "@radix-ui/react-dialog";
import { Sheet, SheetPortal } from "@/src/components/ui/sheet";
@@ -52,7 +53,7 @@ export type DataTablePeekViewProps = {
// Event handlers
/** Called to open the peek view. If undefined, row clicks won't trigger peek view opening */
- openPeek?: (id?: string, row?: any) => void;
+ openPeek?: (id?: string, row?: any, options?: PeekOpenOptions) => void;
/** Called to close the peek view*/
closePeek: () => void;
/** Called when the peek view is expanded to full view */
diff --git a/web/src/components/table/peek/hooks/usePeekNavigation.clienttest.tsx b/web/src/components/table/peek/hooks/usePeekNavigation.clienttest.tsx
index 81c566be95..8d7677e5e4 100644
--- a/web/src/components/table/peek/hooks/usePeekNavigation.clienttest.tsx
+++ b/web/src/components/table/peek/hooks/usePeekNavigation.clienttest.tsx
@@ -179,3 +179,42 @@ describe("usePeekNavigation analytics", () => {
expect(capture).not.toHaveBeenCalled();
});
});
+
+describe("peek entry parameters", () => {
+ it("sets explicit entry parameters and clears them on ordinary entry and close", () => {
+ mockPush.mockReset();
+ window.history.replaceState(
+ {},
+ "",
+ "/project/p1/traces?peek=old&comments=open",
+ );
+ const { result } = renderHook(() =>
+ usePeekNavigation({
+ queryParams: ["annotation", "comments", "traceId"],
+ tableName: "experimentItems",
+ isV4: true,
+ extractParamsValuesFromRow: (row) => ({ traceId: row.traceId }),
+ }),
+ );
+ result.current.openPeek(
+ "item",
+ { traceId: "trace" },
+ { queryParams: { annotation: "open" } },
+ );
+ expect(mockPush.mock.lastCall?.[0].query).toMatchObject({
+ peek: "item",
+ traceId: "trace",
+ annotation: "open",
+ });
+ expect(mockPush.mock.lastCall?.[0].query).not.toHaveProperty("comments");
+ window.history.replaceState(
+ {},
+ "",
+ "/project/p1/traces?peek=item&annotation=open",
+ );
+ result.current.openPeek("item", { traceId: "trace" });
+ expect(mockPush.mock.lastCall?.[0].query).not.toHaveProperty("annotation");
+ result.current.closePeek();
+ expect(mockPush.mock.lastCall?.[0].query).not.toHaveProperty("annotation");
+ });
+});
diff --git a/web/src/components/table/peek/hooks/usePeekNavigation.ts b/web/src/components/table/peek/hooks/usePeekNavigation.ts
index 63f3dff2e1..38d8f8f124 100644
--- a/web/src/components/table/peek/hooks/usePeekNavigation.ts
+++ b/web/src/components/table/peek/hooks/usePeekNavigation.ts
@@ -58,9 +58,13 @@ interface PeekConfigWithExpand extends BasePeekConfig {
};
}
+export type PeekOpenOptions = {
+ queryParams?: Record<string, string>;
+};
+
interface BasePeekNavigation {
/** Open or close peek view. Pass id to open */
- openPeek: (id?: string, row?: any) => void;
+ openPeek: (id?: string, row?: any, options?: PeekOpenOptions) => void;
/** Close the peek view */
closePeek: () => void;
/** Resolve the navigation path for a detail entry */
@@ -98,7 +102,7 @@ export function usePeekNavigation(config: PeekConfig | PeekConfigWithExpand) {
const { isV4, tableName } = config;
const openPeek = useCallback(
- (id?: string, row?: any) => {
+ (id?: string, row?: any, options?: PeekOpenOptions) => {
const pathname = getPathnameWithoutBasePath();
const url = new URL(window.location.href);
const params = new URLSearchParams(url.search);
@@ -142,6 +146,12 @@ export function usePeekNavigation(config: PeekConfig | PeekConfigWithExpand) {
}
}
+ if (id) {
+ Object.entries(options?.queryParams ?? {}).forEach(([key, value]) => {
+ params.set(key, value);
+ });
+ }
+
router.push(
{
pathname,
diff --git a/web/src/features/comments/CommentDrawerController.clienttest.tsx b/web/src/features/comments/CommentDrawerController.clienttest.tsx
index 2716fbc503..b975c46adb 100644
--- a/web/src/features/comments/CommentDrawerController.clienttest.tsx
+++ b/web/src/features/comments/CommentDrawerController.clienttest.tsx
@@ -111,6 +111,7 @@ describe("CommentDrawerController", () => {
fireEvent.click(screen.getByRole("button", { name: "Open comments" }));
expect(screen.getByRole("status")).toHaveTextContent(target.objectId);
expect(fetchComments).not.toHaveBeenCalled();
+ expect(router.replace).not.toHaveBeenCalled();
expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
expect(renderView).toHaveBeenCalledTimes(initialRenders);
fireEvent.click(screen.getByRole("button", { name: "Close review" }));
diff --git a/web/src/features/comments/CommentDrawerController.tsx b/web/src/features/comments/CommentDrawerController.tsx
index f43f0a642f..dba4537e0c 100644
--- a/web/src/features/comments/CommentDrawerController.tsx
+++ b/web/src/features/comments/CommentDrawerController.tsx
@@ -3,7 +3,10 @@ import { useRef, useState, type ReactNode } from "react";
import { type CommentObjectType } from "@langfuse/shared";
import { useHasProjectAccess } from "@/src/features/rbac";
import { api } from "@/src/utils/api";
-import { useTraceReviewPanelOptional } from "@/src/features/traces/contexts/TraceReviewPanelContext";
+import {
+ useTraceReviewPanelOptional,
+ useReviewPanelOpen,
+} from "@/src/features/traces/contexts/TraceReviewPanelContext";
import {
createCommentOverlayStore,
type CommentTarget,
@@ -55,6 +58,7 @@ export function CommentDrawerController({
onCommentChange,
}: CommentDrawerControllerProps) {
const router = useRouter();
+ const onOpen = useReviewPanelOpen();
const reviewPanel = useTraceReviewPanelOptional();
const [store] = useState(createCommentOverlayStore);
const triggerRef = useRef<HTMLElement | null>(null);
@@ -89,6 +93,14 @@ export function CommentDrawerController({
confirmDiscard: () =>
window.confirm("Discard your unsent comment?"),
});
+ const current = reviewPanel.getState();
+ if (
+ current.active === "comments" &&
+ current.comments?.target.objectId === target.objectId &&
+ current.comments.target.objectType === target.objectType
+ ) {
+ onOpen?.("comments", target);
+ }
return;
}
store.getState().actions.open({
diff --git a/web/src/features/experiments/components/table/ExperimentGridCell.clienttest.tsx b/web/src/features/experiments/components/table/ExperimentGridCell.clienttest.tsx
index bdd74eb00e..f76cca12c4 100644
--- a/web/src/features/experiments/components/table/ExperimentGridCell.clienttest.tsx
+++ b/web/src/features/experiments/components/table/ExperimentGridCell.clienttest.tsx
@@ -6,6 +6,7 @@ import {
waitFor,
} from "@testing-library/react";
import type { VisibilityState } from "@tanstack/react-table";
+import type { ComponentProps } from "react";
import { ExperimentGridCell } from "./ExperimentGridCell";
import { TooltipProvider } from "@/src/components/ui/tooltip";
@@ -34,6 +35,8 @@ const renderGridCell = (
output: unknown = null,
onExperimentClick?: (event: React.MouseEvent) => void,
isBaseline = true,
+ onAnnotate?: () => void,
+ overrides: Partial<ComponentProps<typeof ExperimentGridCell>> = {},
) =>
render(
<TooltipProvider>
@@ -41,6 +44,7 @@ const renderGridCell = (
projectId="project-id"
itemId="item-id"
onExperimentClick={onExperimentClick}
+ onAnnotate={onAnnotate}
output={output}
level="GENERATION"
startTime={new Date("2026-07-30T10:00:00.000Z")}
@@ -87,11 +91,68 @@ const renderGridCell = (
}}
columnVisibility={columnVisibility}
showScoreLevelLabels={showScoreLevelLabels}
+ {...overrides}
/>
</TooltipProvider>,
);
describe("ExperimentGridCell", () => {
+ it("keeps categorical changes compact and only reveals the transition when diffs are enabled", async () => {
+ const key = "accuracy-ANNOTATION-CATEGORICAL";
+ for (const showDiff of [true, false]) {
+ const view = renderGridCell(
+ false,
+ undefined,
+ null,
+ undefined,
+ false,
+ undefined,
+ {
+ showDiff,
+ observationScoreOrder: [key],
+ scores: {
+ [key]: {
+ type: "CATEGORICAL",
+ values: ["Partially Correct"],
+ valueCounts: [{ value: "Partially Correct", count: 1 }],
+ id: "current",
+ },
+ },
+ baselineScores: {
+ [key]: {
+ type: "CATEGORICAL",
+ values: ["Incorrect"],
+ valueCounts: [{ value: "Incorrect", count: 1 }],
+ id: "baseline",
+ },
+ },
+ },
+ );
+ expect(
+ screen.queryByLabelText("Changed compared to baseline") !== null,
+ ).toBe(showDiff);
+ expect(
+ screen.queryByText("← Baseline: Incorrect"),
+ ).not.toBeInTheDocument();
+ fireEvent.pointerEnter(screen.getByText("accuracy"));
+ await act(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 750));
+ });
+ expect(screen.queryByText("← Baseline: Incorrect") !== null).toBe(
+ showDiff,
+ );
+ view.unmount();
+ }
+ });
+ it("opens annotation without also triggering the normal cell click", () => {
+ const onAnnotate = vi.fn();
+ const onExperimentClick = vi.fn();
+ renderGridCell(false, undefined, null, onExperimentClick, true, onAnnotate);
+ fireEvent.click(screen.getByRole("button", { name: "Annotate" }));
+ expect(onAnnotate).toHaveBeenCalledOnce();
+ expect(onExperimentClick).not.toHaveBeenCalled();
+ });
+
it("keeps inline score diffs without explanatory native tooltips", () => {
const { unmount } = renderGridCell(
false,
@@ -112,8 +173,8 @@ describe("ExperimentGridCell", () => {
it("shows full labels for every score when both levels are present", () => {
renderGridCell(true);
- expect(screen.getByText("Observation")).toBeInTheDocument();
- expect(screen.getByText("Trace")).toBeInTheDocument();
+ expect(screen.getByText("Observation: quality")).toBeInTheDocument();
+ expect(screen.getByText("Trace: correctness")).toBeInTheDocument();
});
it("omits score level decoration when only one level is present", () => {
diff --git a/web/src/features/experiments/components/table/ExperimentGridCell.tsx b/web/src/features/experiments/components/table/ExperimentGridCell.tsx
index 8f5c0beade..079a87cf0c 100644
--- a/web/src/features/experiments/components/table/ExperimentGridCell.tsx
+++ b/web/src/features/experiments/components/table/ExperimentGridCell.tsx
@@ -30,8 +30,8 @@ import {
HoverCardContent,
HoverCardTrigger,
} from "@/src/components/ui/hover-card";
-import { Copy, Check, ExternalLink } from "lucide-react";
-import { Button } from "@/src/components/ui/button";
+import { Copy, Check, ExternalLink, SquarePen } from "lucide-react";
+import { Button } from "@/src/components/design-system/Button/Button";
import { copyTextToClipboard } from "@/src/utils/clipboard";
import { api } from "@/src/utils/api";
import { Skeleton } from "@/src/components/ui/skeleton";
@@ -39,7 +39,7 @@ import { JSONView } from "@/src/components/ui/CodeJsonViewer";
import { decomposeAggregateScoreKey } from "@/src/features/scores";
import { cn } from "@/src/utils/tailwind";
import Link from "next/link";
-import { ScoreTag, type ScoreLevel } from "@/src/components/score-tag";
+import { type ScoreLevel } from "@/src/components/score-tag";
import { NotRecordedMetric } from "./NotRecordedMetric";
import { describeRunComparison } from "@/src/features/experiments/fns/describeRunComparison";
@@ -74,6 +74,7 @@ type ExperimentGridCellProps = {
showScoreLevelLabels: boolean;
/** Clicking this experiment's cell selects it in peek navigation instead of the row's default (baseline) target. */
onExperimentClick?: (event: React.MouseEvent) => void;
+ onAnnotate?: () => void;
};
/**
@@ -128,7 +129,7 @@ const formatCost = (value: number) => usdFormatter(value, 4, 4);
const valueColumnsClass = (showBaselineDelta: boolean) =>
showBaselineDelta
- ? "grid shrink-0 grid-cols-[auto_4.5rem] items-center justify-items-start gap-1"
+ ? "grid max-w-full shrink-0 grid-cols-[minmax(0,auto)_4.5rem] items-center justify-items-start gap-1"
: "flex shrink-0 items-center justify-end gap-1";
/**
@@ -180,8 +181,9 @@ const ScoreItem = ({
className="flex cursor-default items-center justify-between gap-2 text-xs"
>
<div className="flex min-w-0 items-center gap-1">
- {showScoreLevelLabel && <ScoreTag level={level} />}
<span className="text-muted-foreground line-clamp-1 min-w-0">
+ {showScoreLevelLabel &&
+ `${level === "trace" ? "Trace" : "Observation"}: `}
{name}
</span>
</div>
@@ -202,7 +204,16 @@ const ScoreItem = ({
</Badge>
)}
</span>
- {diff && (
+ {diff?.type === "CATEGORICAL" && (
+ <span
+ className="text-muted-foreground text-xs"
+ aria-label="Changed compared to baseline"
+ title="Changed compared to baseline"
+ >
+ ↻
+ </span>
+ )}
+ {diff?.type === "NUMERIC" && (
<DiffLabel
variant="ghost"
className="px-0"
@@ -215,14 +226,23 @@ const ScoreItem = ({
</HoverCardTrigger>
<HoverCardContent
align="start"
- className="max-h-[50vh] w-80 overflow-auto text-xs break-words whitespace-normal"
+ className="max-h-[50vh] w-96 overflow-auto text-xs break-words whitespace-normal"
onClick={(event) => event.stopPropagation()}
>
<div className="flex flex-col gap-3">
<span className="font-bold">{name}</span>
<dl className="grid grid-cols-[auto_1fr] gap-x-4 gap-y-1">
<dt className="text-muted-foreground">Value</dt>
- <dd>{displayValue}</dd>
+ <dd className="min-w-0">
+ {displayValue}
+ {diff?.type === "CATEGORICAL" && (
+ <span className="text-muted-foreground ml-2 whitespace-normal">
+ {diff.from
+ ? `← Baseline: ${diff.from}`
+ : "Varies from baseline"}
+ </span>
+ )}
+ </dd>
<dt className="text-muted-foreground">Source</dt>
<dd className="capitalize">{source.toLowerCase()}</dd>
<dt className="text-muted-foreground">Type</dt>
@@ -234,20 +254,15 @@ const ScoreItem = ({
<span className="text-muted-foreground">Comment</span>
<Button
variant="ghost"
- size="icon-xs"
- aria-label={copied ? "Copied" : "Copy comment"}
+ size="sm"
+ text={copied ? "Copied" : "Copy comment"}
+ icon={copied ? Check : Copy}
onClick={async () => {
await copyTextToClipboard(aggregate.comment!);
setCopied(true);
setTimeout(() => setCopied(false), 2000);
}}
- >
- {copied ? (
- <Check className="h-3 w-3" />
- ) : (
- <Copy className="h-3 w-3" />
- )}
- </Button>
+ />
</div>
<p className="whitespace-pre-wrap">{aggregate.comment}</p>
</div>
@@ -486,6 +501,7 @@ export const ExperimentGridCell = ({
markerClassName,
showScoreLevelLabels,
onExperimentClick,
+ onAnnotate,
}: ExperimentGridCellProps) => {
const scoreDiffs = useMemo(
() =>
@@ -494,7 +510,6 @@ export const ExperimentGridCell = ({
: computeScoreDiffs(scores, baselineScores),
[scores, baselineScores, isBaseline, showDiff],
);
-
const traceScoreDiffs = useMemo(
() =>
!showDiff || isBaseline || !baselineTraceScores
@@ -518,22 +533,6 @@ export const ExperimentGridCell = ({
[baselineLatencyMs, isBaseline, latencyMs, showDiff],
);
- const orderedObservationKeys = useMemo(
- () =>
- observationScoreOrder.length > 0
- ? observationScoreOrder
- : Object.keys(scores).sort(),
- [observationScoreOrder, scores],
- );
-
- const orderedTraceKeys = useMemo(
- () =>
- traceScoreOrder.length > 0
- ? traceScoreOrder
- : Object.keys(traceScores).sort(),
- [traceScoreOrder, traceScores],
- );
-
const cellData: GridCellData = {
showBaselineDelta: !isBaseline && showDiff,
projectId,
@@ -561,68 +560,59 @@ export const ExperimentGridCell = ({
// Define cell rows declaratively - mirrors LangfuseColumnDef pattern
// Fixed order: scores, metrics, output
- const cellRows: CellRowDef<GridCellData>[] = useMemo(
- () => [
- // Keep all score levels together. Individual score visibility still
- // follows the list-view columns.
- {
- accessorKey: "scores",
- header: "Scores",
- children: [
- ...(columnVisibility.observationScores !== false
- ? orderedObservationKeys.map((key) =>
- getScoreRowDefinition(key, "observation", showScoreLevelLabels),
- )
- : []),
- ...(columnVisibility.traceScores !== false
- ? orderedTraceKeys.map((key) =>
- getScoreRowDefinition(key, "trace", showScoreLevelLabels),
- )
- : []),
- ],
- },
- // Measurements share the scores' value and delta alignment.
- ...(hasVisibleCellMetadata(columnVisibility)
- ? ([
- {
- accessorKey: "metadata",
- cell: ({ data }) => (
- <CellMetadataFooter
- data={data}
- columnVisibility={columnVisibility}
- />
- ),
- },
- ] satisfies CellRowDef<GridCellData>[])
- : []),
- // Output section
- {
- accessorKey: "output",
- header: "Output",
- cell: ({ data }) =>
- data.isLoading ? (
- <ConnectedIOTableCell
- isLoading
- variant="output"
- singleLine={singleLine}
- />
- ) : (
- <ConnectedIOTableCell
- data={data.output ?? null}
- variant="output"
- singleLine={singleLine}
- />
- ),
- },
- ],
- [
- columnVisibility,
- orderedObservationKeys,
- orderedTraceKeys,
- showScoreLevelLabels,
- singleLine,
- ],
- );
+ const cellRows: CellRowDef<GridCellData>[] = [
+ // Keep all score levels together. Individual score visibility still
+ // follows the list-view columns.
+ {
+ accessorKey: "scores",
+ header: "Scores",
+ children: [
+ ...(columnVisibility.observationScores !== false
+ ? observationScoreOrder.map((key) =>
+ getScoreRowDefinition(key, "observation", showScoreLevelLabels),
+ )
+ : []),
+ ...(columnVisibility.traceScores !== false
+ ? traceScoreOrder.map((key) =>
+ getScoreRowDefinition(key, "trace", showScoreLevelLabels),
+ )
+ : []),
+ ],
+ },
+ // Measurements share the scores' value and delta alignment.
+ ...(hasVisibleCellMetadata(columnVisibility)
+ ? ([
+ {
+ accessorKey: "metadata",
+ cell: ({ data }) => (
+ <CellMetadataFooter
+ data={data}
+ columnVisibility={columnVisibility}
+ />
+ ),
+ },
+ ] satisfies CellRowDef<GridCellData>[])
+ : []),
+ // Output section
+ {
+ accessorKey: "output",
+ header: "Output",
+ cell: ({ data }) =>
+ data.isLoading ? (
+ <ConnectedIOTableCell
+ isLoading
+ variant="output"
+ singleLine={singleLine}
+ />
+ ) : (
+ <ConnectedIOTableCell
+ data={data.output ?? null}
+ variant="output"
+ singleLine={singleLine}
+ />
+ ),
+ },
+ ];
// Filter and compute visible rows
const visibleRows = getVisibleCellRows(cellRows, columnVisibility);
@@ -655,74 +645,90 @@ export const ExperimentGridCell = ({
return (
<div
className={cn(
- "scrollbar-visible flex h-full min-h-0 w-full min-w-0 flex-1 flex-col overflow-auto",
+ "group/grid-cell relative flex h-full min-h-0 w-full min-w-0 flex-1 flex-col",
onExperimentClick && "cursor-pointer",
)}
onClick={onExperimentClick}
>
- {sectionsToRender.map((section, index) => {
- const { row, content } = section;
- const isFirst = index === 0;
- const isLast = index === sectionsToRender.length - 1;
+ {onAnnotate && (
+ <div className="bg-background absolute right-1 bottom-1 z-1 rounded-md opacity-0 group-focus-within/grid-cell:opacity-100 group-hover/grid-cell:opacity-100">
+ <Button
+ text="Annotate"
+ icon={SquarePen}
+ variant="ghost"
+ size="sm"
+ onClick={(event) => {
+ event.stopPropagation();
+ onAnnotate();
+ }}
+ />
+ </div>
+ )}
+ <div className="scrollbar-visible flex min-h-0 flex-1 flex-col overflow-auto">
+ {sectionsToRender.map((section, index) => {
+ const { row, content } = section;
+ const isFirst = index === 0;
+ const isLast = index === sectionsToRender.length - 1;
- // Output section - special handling for ConnectedIOTableCell. It is the
- // one section that grows, so a taller row shows more output rather than
- // more chrome.
- if (row.accessorKey === "output" && row.cell) {
- return (
- <Fragment key={row.accessorKey}>
- <GroupSection
- header={row.header}
- markerClassName={isFirst ? markerClassName : undefined}
- grow
- >
- <div className="min-h-16 flex-1 overflow-hidden">
- {row.cell({ data: cellData })}
- </div>
- </GroupSection>
- {!isLast && <Separator />}
- </Fragment>
- );
- }
+ // Output section - special handling for ConnectedIOTableCell. It is the
+ // one section that grows, so a taller row shows more output rather than
+ // more chrome.
+ if (row.accessorKey === "output" && row.cell) {
+ return (
+ <Fragment key={row.accessorKey}>
+ <GroupSection
+ header={row.header}
+ markerClassName={isFirst ? markerClassName : undefined}
+ grow
+ >
+ <div className="min-h-16 flex-1 overflow-hidden">
+ {row.cell({ data: cellData })}
+ </div>
+ </GroupSection>
+ {!isLast && <Separator />}
+ </Fragment>
+ );
+ }
- // Groups with children (metadata, scores)
- if (row.children && content) {
- return (
- <Fragment key={row.accessorKey}>
- <GroupSection
- header={row.header}
- markerClassName={isFirst ? markerClassName : undefined}
- >
- <div className="flex flex-col gap-0.5">
- {(content as CellRowDef<GridCellData>[]).map((child) => (
- <div key={child.accessorKey}>
- {child.cell?.({ data: cellData })}
- </div>
- ))}
- </div>
- </GroupSection>
- {!isLast && <Separator />}
- </Fragment>
- );
- }
+ // Groups with children (metadata, scores)
+ if (row.children && content) {
+ return (
+ <Fragment key={row.accessorKey}>
+ <GroupSection
+ header={row.header}
+ markerClassName={isFirst ? markerClassName : undefined}
+ >
+ <div className="flex flex-col gap-0.5">
+ {(content as CellRowDef<GridCellData>[]).map((child) => (
+ <div key={child.accessorKey}>
+ {child.cell?.({ data: cellData })}
+ </div>
+ ))}
+ </div>
+ </GroupSection>
+ {!isLast && <Separator />}
+ </Fragment>
+ );
+ }
- // Sections that render one cell of their own (the metadata footer).
- if (row.cell) {
- return (
- <Fragment key={row.accessorKey}>
- <GroupSection
- header={row.header}
- markerClassName={isFirst ? markerClassName : undefined}
- >
- {row.cell({ data: cellData })}
- </GroupSection>
- {!isLast && <Separator />}
- </Fragment>
- );
- }
+ // Sections that render one cell of their own (the metadata footer).
+ if (row.cell) {
+ return (
+ <Fragment key={row.accessorKey}>
+ <GroupSection
+ header={row.header}
+ markerClassName={isFirst ? markerClassName : undefined}
+ >
+ {row.cell({ data: cellData })}
+ </GroupSection>
+ {!isLast && <Separator />}
+ </Fragment>
+ );
+ }
- return null;
- })}
+ return null;
+ })}
+ </div>
</div>
);
};
diff --git a/web/src/features/experiments/components/table/ExperimentGridSummary.tsx b/web/src/features/experiments/components/table/ExperimentGridSummary.tsx
index 9fb4eea25b..db013a74aa 100644
--- a/web/src/features/experiments/components/table/ExperimentGridSummary.tsx
+++ b/web/src/features/experiments/components/table/ExperimentGridSummary.tsx
@@ -167,7 +167,7 @@ export function ExperimentGridSummaryValues({
{!isLoading && movement && (
<div
className="flex shrink-0 items-center gap-2 text-xs font-normal"
- title={`${movement.unchanged} unchanged; ${movement.notComparable} not comparable`}
+ title={`${movement.changed} items changed compared to baseline; ${movement.unchanged} unchanged; ${movement.notComparable} uncomparable`}
>
{dataType === "CATEGORICAL" ? (
<span aria-label={`${movement.changed} changed items`}>
diff --git a/web/src/features/experiments/components/table/ExperimentGridView.tsx b/web/src/features/experiments/components/table/ExperimentGridView.tsx
index c1da5392aa..531e6d6e4c 100644
--- a/web/src/features/experiments/components/table/ExperimentGridView.tsx
+++ b/web/src/features/experiments/components/table/ExperimentGridView.tsx
@@ -25,6 +25,9 @@ import { useExperimentNames } from "@/src/features/experiments/hooks/useExperime
import { cn } from "@/src/utils/tailwind";
import { type DataTablePeekViewProps } from "@/src/components/table/peek";
+import { useHasProjectAccess } from "@/src/features/rbac";
+import { usePostHogClientCapture } from "@/src/features/posthog-analytics";
+
// Grid view row heights (matching DatasetCompareRunsTable)
const GRID_VIEW_ROW_HEIGHTS = {
s: "h-48", // 192px
@@ -98,6 +101,8 @@ export const ExperimentGridView = ({
setRowSelection,
highlightAllRows,
}: ExperimentGridViewProps) => {
+ const canAnnotate = useHasProjectAccess({ projectId, scope: "scores:CUD" });
+ const capture = usePostHogClientCapture();
const [summaryExpanded, setSummaryExpanded] = useState(true);
// Keep the explicit baseline separate from the comparison list. A baseline
// is optional, so c-only URLs render every selected experiment here.
@@ -228,6 +233,27 @@ export const ExperimentGridView = ({
}
columnVisibility={columnVisibility}
markerClassName={colorStyles?.markerClass}
+ onAnnotate={
+ canAnnotate &&
+ peekView?.openPeek &&
+ expData.traceId &&
+ expData.observationId
+ ? () => {
+ capture("annotation:entry_click", {
+ type: "trace",
+ source: "DatasetCompare",
+ isV4: true,
+ targetType: "observation",
+ entryPoint: "annotate_button",
+ });
+ peekView.openPeek?.(
+ row.original.itemId,
+ { ...row.original, clickedExperimentId: expId },
+ { queryParams: { annotation: "open" } },
+ );
+ }
+ : undefined
+ }
onExperimentClick={
peekView?.openPeek
? (event) => {
@@ -262,6 +288,8 @@ export const ExperimentGridView = ({
showDiff,
singleLine,
peekView,
+ canAnnotate,
+ capture,
]);
// Build all columns: Select, Input, Expected Output, then experiment columns
diff --git a/web/src/features/experiments/components/table/ExperimentItemsTable.tsx b/web/src/features/experiments/components/table/ExperimentItemsTable.tsx
index 2b33a12a4c..0a08299264 100644
--- a/web/src/features/experiments/components/table/ExperimentItemsTable.tsx
+++ b/web/src/features/experiments/components/table/ExperimentItemsTable.tsx
@@ -1,5 +1,6 @@
/* eslint-disable no-nested-ternary */
/* eslint-disable @repo/no-style-props */
+import { useRouter } from "next/router";
import { useExperimentResultsState } from "@/src/features/experiments/hooks/useExperimentResultsState";
import { DataTableToolbar } from "@/src/components/table/data-table-toolbar";
import {
@@ -86,6 +87,7 @@ import {
} from "@/src/features/scores";
import { Skeleton } from "@/src/components/ui/skeleton";
import { ExperimentCompareTable } from "./ExperimentCompareTable";
+import { useExperimentItemsScoreCache } from "@/src/features/experiments/hooks/useExperimentItemsScoreCache";
import { useExperimentNames } from "@/src/features/experiments/hooks/useExperimentNames";
import {
useExperimentItemsFilterOptions,
@@ -178,7 +180,7 @@ function toScoreColumnInput(scoreColumnDefs: ScoreColumnDef[]): Array<{
/**
* One summary per score column: the primary experiment's aggregate over the
* items in view, and the same for the comparison it is read against. Built once
- * per fetch rather than per header render.
+ * per score snapshot rather than per header render.
*/
function buildScoreColumnSummaries({
rows,
@@ -526,6 +528,7 @@ export default function ExperimentItemsTable({
hideControls = false,
toolbarSettings,
}: ExperimentItemsTableProps) {
+ const router = useRouter();
const { setDetailPageList } = useDetailPageLists();
const [selectedRows, setSelectedRows] = useState<RowSelectionState>({});
const [showRunEvaluationDialog, setShowRunEvaluationDialog] = useState(false);
@@ -631,7 +634,7 @@ export default function ExperimentItemsTable({
// Fetch score filter options scoped to selected experiments
const {
filterOptions: scoreFilterOptions,
- scoreColumns: scoreColumnDefs,
+ scoreColumns: serverScoreColumnDefs,
isLoading: isFilterOptionsLoading,
} = useExperimentItemsFilterOptions({
projectId,
@@ -799,6 +802,9 @@ export default function ExperimentItemsTable({
itemVisibility,
});
+ const { rows: scoreRows, scoreColumns: scoreColumnDefs } =
+ useExperimentItemsScoreCache(items.rows, serverScoreColumnDefs);
+
// Running items without an expected output is common, so don't spend a column
// on it before loaded IO confirms there is expected output to display.
//
@@ -844,7 +850,7 @@ export default function ExperimentItemsTable({
// columns don't disappear and come back on each fetch.
const presentScoreKeys = useMemo(() => {
if (items.status !== "success") return undefined;
- const experimentsInView = (items.rows ?? []).flatMap(
+ const experimentsInView = (scoreRows ?? []).flatMap(
(row) => row.experiments,
);
return {
@@ -855,10 +861,9 @@ export default function ExperimentItemsTable({
experimentsInView.map((exp) => exp.traceScores),
),
};
- }, [items]);
+ }, [items.status, scoreRows]);
- // Create score columns from the shared filter options data
- // This ensures sidebar filters and column visibility use the same data source
+ // Column visibility and both table layouts share the cache-inclusive score columns.
const observationScoreColumns = useMemo(
() =>
createScoreColumns<ExperimentItemData>({
@@ -1024,7 +1029,7 @@ export default function ExperimentItemsTable({
);
const scoreColumnSummaries = useMemo(() => {
- const rowsInView = items.rows ?? [];
+ const rowsInView = scoreRows ?? [];
return {
observationScores: buildScoreColumnSummaries({
rows: rowsInView,
@@ -1042,7 +1047,7 @@ export default function ExperimentItemsTable({
}),
};
}, [
- items.rows,
+ scoreRows,
scoreDataTypesByKey,
primaryExperimentId,
primaryComparisonId,
@@ -1665,6 +1670,10 @@ export default function ExperimentItemsTable({
"timestamp",
"traceId",
"peekExperimentId",
+ "annotation",
+ "comments",
+ "commentObjectType",
+ "commentObjectId",
],
tableName: experimentItemsFilterConfig.tableName,
isV4: true,
@@ -1754,18 +1763,37 @@ export default function ExperimentItemsTable({
itemType: "TRACE",
detailNavigationKey: "experiment-items",
...peekNavigationProps,
+ resolveDetailNavigationPath: (entry) =>
+ peekNavigationProps.resolveDetailNavigationPath({
+ ...entry,
+ params: {
+ ...entry.params,
+ ...(router.query.annotation === "open"
+ ? { annotation: "open" }
+ : {}),
+ ...(router.query.annotation !== "open" &&
+ router.query.comments === "open"
+ ? { comments: "open" }
+ : {}),
+ },
+ }),
};
- }, [peekNavigationProps, canUsePeek]);
+ }, [
+ peekNavigationProps,
+ canUsePeek,
+ router.query.annotation,
+ router.query.comments,
+ ]);
- // The page as fetched. The score column header aggregates — and the score
- // matrix, which reads the same ones — deliberately describe this whole page,
+ // The fetched page with local score writes. The column header aggregates and
+ // the score matrix deliberately describe this whole page,
// so the movement a comparison filter was built from stays readable while
// that filter is applied.
const unfilteredRows: ExperimentItemsTableRow[] = useMemo(() => {
- if (items.status !== "success" || !items.rows) return [];
+ if (items.status !== "success" || !scoreRows) return [];
// Add 'id' field for DataTable row identification (peek view requires it)
- return items.rows.map((row) => ({ ...row, id: row.itemId }));
- }, [items]);
+ return scoreRows.map((row) => ({ ...row, id: row.itemId }));
+ }, [items.status, scoreRows]);
// The score comparison filters narrow the page here rather than in the
// query — see `useScoreComparisonFilters` for why.
diff --git a/web/src/features/experiments/hooks/useExperimentItemsScoreCache.clienttest.tsx b/web/src/features/experiments/hooks/useExperimentItemsScoreCache.clienttest.tsx
new file mode 100644
index 0000000000..1a92cf3d51
--- /dev/null
+++ b/web/src/features/experiments/hooks/useExperimentItemsScoreCache.clienttest.tsx
@@ -0,0 +1,227 @@
+import {
+ act,
+ render,
+ renderHook,
+ screen,
+ within,
+} from "@testing-library/react";
+import {
+ ScoreCacheProvider,
+ useScoreCache,
+ type CachedScore,
+} from "@/src/features/scores/contexts/ScoreCacheContext";
+import { ExperimentGridSummaryValues } from "../components/table/ExperimentGridSummary";
+import {
+ type ExperimentItemsTableRow,
+ type ExperimentItemData,
+} from "../components/table/types";
+import { useExperimentItemsScoreCache } from "./useExperimentItemsScoreCache";
+
+const rows: ExperimentItemsTableRow[] = ["first", "second"].map((itemId) => ({
+ itemId,
+ experiments: ["baseline", "comparison"].map((experimentId) => ({
+ experimentId,
+ traceId: `${itemId}-${experimentId}-trace`,
+ observationId: `${itemId}-${experimentId}-observation`,
+ startTime: new Date("2026-09-01"),
+ level: "DEFAULT",
+ observationScores: {},
+ traceScores: {},
+ })),
+}));
+const scoreColumns = { observationScoreColumns: [], traceScoreColumns: [] };
+const score: CachedScore = {
+ id: "annotation-id",
+ projectId: "project-id",
+ environment: "default",
+ name: "review",
+ source: "ANNOTATION",
+ dataType: "NUMERIC",
+ configId: "config-id",
+ value: 0.42,
+ stringValue: null,
+ comment: null,
+ traceId: "first-comparison-trace",
+ observationId: "first-comparison-observation",
+ sessionId: null,
+ timestamp: new Date("2026-09-01"),
+};
+
+let cache: ReturnType<typeof useScoreCache>;
+let data: ReturnType<typeof useExperimentItemsScoreCache>;
+function TableScores() {
+ cache = useScoreCache();
+ data = useExperimentItemsScoreCache(rows, scoreColumns);
+ return (
+ <>
+ {["baseline", "comparison"].map((experimentId) => (
+ <div key={experimentId} data-testid={experimentId}>
+ <ExperimentGridSummaryValues
+ rows={data.rows ?? []}
+ experimentId={experimentId}
+ baselineExperimentId="baseline"
+ observationScoreOrder={data.scoreColumns.observationScoreColumns.map(
+ ({ name, source, dataType }) => `${name}-${source}-${dataType}`,
+ )}
+ traceScoreOrder={data.scoreColumns.traceScoreColumns.map(
+ ({ name, source, dataType }) => `${name}-${source}-${dataType}`,
+ )}
+ columnVisibility={{}}
+ showScoreLevelLabels
+ expanded
+ showScoreNames
+ isLoading={false}
+ onToggle={() => {}}
+ />
+ </div>
+ ))}
+ </>
+ );
+}
+
+it("shares a new score column across the table and updates summaries from cached writes", () => {
+ render(
+ <ScoreCacheProvider>
+ <TableScores />
+ </ScoreCacheProvider>,
+ );
+ act(() => {
+ cache.set(score.id, score);
+ cache.setColumn(score);
+ });
+ expect(
+ within(screen.getByTestId("baseline")).getByLabelText(
+ "Observation: review: not scored",
+ ),
+ ).toBeInTheDocument();
+ expect(
+ within(screen.getByTestId("comparison")).getByLabelText(
+ "Observation: review: 0.42",
+ ),
+ ).toBeInTheDocument();
+ expect(
+ data.rows?.[1].experiments.every(
+ (exp) => Object.keys(exp.observationScores).length === 0,
+ ),
+ ).toBe(true);
+ act(() => cache.set(score.id, { ...score, value: 0.63 }));
+ expect(
+ within(screen.getByTestId("comparison")).getByLabelText(
+ "Observation: review: 0.63",
+ ),
+ ).toBeInTheDocument();
+ act(() => cache.delete(score.id));
+ expect(
+ screen.queryByLabelText("Observation: review: 0.63"),
+ ).not.toBeInTheDocument();
+});
+
+it("keeps levels and targets separate while recomputing comparison summaries", () => {
+ render(
+ <ScoreCacheProvider>
+ <TableScores />
+ </ScoreCacheProvider>,
+ );
+ act(() => {
+ cache.setColumn(score);
+ cache.set(score.id, score);
+ cache.set("baseline", {
+ ...score,
+ id: "baseline",
+ traceId: "first-baseline-trace",
+ observationId: "first-baseline-observation",
+ value: 0.21,
+ });
+ cache.set("trace", {
+ ...score,
+ id: "trace",
+ observationId: null,
+ value: 0.91,
+ });
+ cache.set("text", {
+ ...score,
+ id: "text",
+ name: "note",
+ dataType: "TEXT",
+ stringValue: "review note",
+ });
+ cache.set("unrelated", {
+ ...score,
+ id: "unrelated",
+ name: "unrelated",
+ observationId: "other-observation",
+ value: 0.99,
+ });
+ });
+ expect(data.scoreColumns.observationScoreColumns).toHaveLength(1);
+ expect(
+ Object.keys(data.rows?.[0].experiments[1].observationScores ?? {}),
+ ).toEqual(["review-ANNOTATION-NUMERIC"]);
+ expect(
+ within(screen.getByTestId("comparison")).getByLabelText(
+ "Observation: review: 0.42",
+ ),
+ ).toBeInTheDocument();
+ expect(
+ within(screen.getByTestId("comparison")).getByLabelText(
+ "Trace: review: 0.91",
+ ),
+ ).toBeInTheDocument();
+ expect(
+ within(screen.getByTestId("comparison")).getByText("+0.21"),
+ ).toBeInTheDocument();
+ act(() =>
+ cache.set("baseline", {
+ ...score,
+ id: "baseline",
+ traceId: "first-baseline-trace",
+ observationId: "first-baseline-observation",
+ value: 0.12,
+ }),
+ );
+ expect(
+ within(screen.getByTestId("comparison")).getByText("+0.30"),
+ ).toBeInTheDocument();
+});
+
+it("overlays and deletes a persisted score before the server refreshes", () => {
+ const key = "review-ANNOTATION-NUMERIC";
+ const serverRows = rows.map((row) => ({
+ ...row,
+ experiments: row.experiments.map<ExperimentItemData>((experiment) => ({
+ ...experiment,
+ observationScores:
+ experiment.observationId === score.observationId
+ ? {
+ [key]: {
+ type: "NUMERIC" as const,
+ average: 0.1,
+ values: [0.1],
+ id: score.id,
+ },
+ }
+ : experiment.observationScores,
+ })),
+ }));
+ const serverColumns = {
+ observationScoreColumns: [
+ { name: "review", source: "ANNOTATION", dataType: "NUMERIC" as const },
+ ],
+ traceScoreColumns: [],
+ };
+ const { result } = renderHook(
+ () => ({
+ data: useExperimentItemsScoreCache(serverRows, serverColumns),
+ cache: useScoreCache(),
+ }),
+ { wrapper: ScoreCacheProvider },
+ );
+ act(() => result.current.cache.set(score.id, score));
+ expect(
+ result.current.data.rows?.[0].experiments[1].observationScores[key],
+ ).toMatchObject({ average: 0.42 });
+ act(() => result.current.cache.delete(score.id));
+ expect(
+ result.current.data.rows?.[0].experiments[1].observationScores[key],
+ ).toBeUndefined();
+});
diff --git a/web/src/features/experiments/hooks/useExperimentItemsScoreCache.ts b/web/src/features/experiments/hooks/useExperimentItemsScoreCache.ts
new file mode 100644
index 0000000000..2e53353207
--- /dev/null
+++ b/web/src/features/experiments/hooks/useExperimentItemsScoreCache.ts
@@ -0,0 +1,98 @@
+import { useMemo } from "react";
+import { type ScoreAggregate } from "@langfuse/shared";
+import {
+ useScoreCache,
+ type CachedScore,
+} from "@/src/features/scores/contexts/ScoreCacheContext";
+import { composeAggregateScoreKey } from "@/src/features/scores/lib/aggregateScores";
+import { mergeAggregatesWithCache } from "@/src/features/scores/lib/mergeScoresWithCache";
+import { type ExperimentItemsTableRow } from "../components/table/types";
+import { type ScoreColumnDef } from "./useExperimentItemsFilterOptions";
+
+type ExperimentScoreColumns = {
+ observationScoreColumns: ScoreColumnDef[];
+ traceScoreColumns: ScoreColumnDef[];
+};
+
+const columnKey = (column: ScoreColumnDef) =>
+ composeAggregateScoreKey({
+ ...column,
+ source: column.source as "API" | "ANNOTATION" | "EVAL",
+ });
+
+/** One score snapshot for the column selector, cells, summaries and filters. */
+export function useExperimentItemsScoreCache(
+ rows: ExperimentItemsTableRow[] | undefined,
+ scoreColumns: ExperimentScoreColumns,
+) {
+ const { getAllForTarget, isDeleted } = useScoreCache();
+
+ return useMemo(() => {
+ const observationColumns = new Map(
+ scoreColumns.observationScoreColumns.map((column) => [
+ columnKey(column),
+ column,
+ ]),
+ );
+ const traceColumns = new Map(
+ scoreColumns.traceScoreColumns.map((column) => [
+ columnKey(column),
+ column,
+ ]),
+ );
+ const merge = (
+ aggregates: ScoreAggregate,
+ traceId: string,
+ observationId: string | undefined,
+ columns: Map<string, ScoreColumnDef>,
+ ) => {
+ const cached = getAllForTarget("target-scores-only", {
+ traceId,
+ observationId,
+ }).filter(
+ (
+ score,
+ ): score is CachedScore & { dataType: ScoreColumnDef["dataType"] } =>
+ score.dataType === "NUMERIC" ||
+ score.dataType === "BOOLEAN" ||
+ score.dataType === "CATEGORICAL",
+ );
+ for (const { name, source, dataType } of cached) {
+ const column = { name, source, dataType };
+ const key = columnKey(column);
+ if (!columns.has(key)) columns.set(key, column);
+ }
+ const deletedIds = new Set(
+ Object.values(aggregates).flatMap(({ id }) =>
+ id && isDeleted(id) ? [id] : [],
+ ),
+ );
+ return mergeAggregatesWithCache(aggregates, cached, deletedIds);
+ };
+ const mergedRows = rows?.map((row) => ({
+ ...row,
+ experiments: row.experiments.map((experiment) => ({
+ ...experiment,
+ observationScores: merge(
+ experiment.observationScores,
+ experiment.traceId,
+ experiment.observationId,
+ observationColumns,
+ ),
+ traceScores: merge(
+ experiment.traceScores,
+ experiment.traceId,
+ undefined,
+ traceColumns,
+ ),
+ })),
+ }));
+ return {
+ rows: mergedRows,
+ scoreColumns: {
+ observationScoreColumns: Array.from(observationColumns.values()),
+ traceScoreColumns: Array.from(traceColumns.values()),
+ },
+ };
+ }, [rows, scoreColumns, getAllForTarget, isDeleted]);
+}
diff --git a/web/src/features/experiments/hooks/useExperimentPeekNavigation.ts b/web/src/features/experiments/hooks/useExperimentPeekNavigation.ts
index 8b29e48fab..1e759b58a4 100644
--- a/web/src/features/experiments/hooks/useExperimentPeekNavigation.ts
+++ b/web/src/features/experiments/hooks/useExperimentPeekNavigation.ts
@@ -72,6 +72,9 @@ export function useExperimentPeekNavigation() {
params.set("traceId", target.traceId);
params.set("timestamp", target.timestamp);
params.set("observation", target.observationId);
+ if (params.get("annotation") === "open") params.delete("comments");
+ params.delete("commentObjectType");
+ params.delete("commentObjectId");
// router.push re-prepends NEXT_PUBLIC_BASE_PATH, so strip it first
const pathname = getPathnameWithoutBasePath();
diff --git a/web/src/features/scores/components/AnnotateDrawerController.tsx b/web/src/features/scores/components/AnnotateDrawerController.tsx
index 49478a67b9..2e7fa72fa2 100644
--- a/web/src/features/scores/components/AnnotateDrawerController.tsx
+++ b/web/src/features/scores/components/AnnotateDrawerController.tsx
@@ -10,7 +10,10 @@ import { getAnnotationTargetType } from "@/src/features/scores/lib/annotationAna
import { type ScoreDomain } from "@langfuse/shared";
import { type WithStringifiedMetadata } from "@/src/utils/clientSideDomainTypes";
import { AnnotationPanelContent } from "./AnnotationPanelContent";
-import { useTraceReviewPanelOptional } from "@/src/features/traces/contexts/TraceReviewPanelContext";
+import {
+ useTraceReviewPanelOptional,
+ useReviewPanelOpen,
+} from "@/src/features/traces/contexts/TraceReviewPanelContext";
import { useIsMobile } from "@/src/hooks/use-mobile";
export type AnnotateDrawerControllerProps<Target extends ScoreTarget> = {
@@ -38,6 +41,7 @@ export function AnnotateDrawerController<Target extends ScoreTarget>({
children,
projectId,
}: AnnotateDrawerControllerProps<Target>) {
+ const onOpen = useReviewPanelOpen();
const capture = usePostHogClientCapture();
const reviewPanel = useTraceReviewPanelOptional();
const isMobile = useIsMobile();
@@ -90,6 +94,7 @@ export function AnnotateDrawerController<Target extends ScoreTarget>({
.getState()
.actions.rememberTrigger(triggerRef.current);
reviewPanel.getState().actions.openAnnotation(payload);
+ onOpen?.("annotation");
} else openDrawer(payload);
},
})
diff --git a/web/src/features/scores/lib/prepareTraceAnnotation.ts b/web/src/features/scores/lib/prepareTraceAnnotation.ts
new file mode 100644
index 0000000000..95443e909a
--- /dev/null
+++ b/web/src/features/scores/lib/prepareTraceAnnotation.ts
@@ -0,0 +1,31 @@
+import { type ScoreDomain } from "@langfuse/shared";
+import { type WithStringifiedMetadata } from "@/src/utils/clientSideDomainTypes";
+import { type AnnotationPanelData } from "../types";
+
+/** Prepare the single selected trace or observation for the annotation form. */
+export function prepareTraceAnnotation({
+ traceId,
+ projectId,
+ environment,
+ observationId,
+ scores,
+ isV4,
+}: {
+ traceId: string;
+ projectId: string;
+ environment: string;
+ observationId?: string;
+ scores: WithStringifiedMetadata<ScoreDomain>[];
+ isV4: boolean;
+}) {
+ return {
+ scoreTarget: { type: "trace", traceId, observationId },
+ scores: scores.filter((score) =>
+ observationId
+ ? score.observationId === observationId
+ : !score.observationId,
+ ),
+ analyticsData: { type: "trace", source: "TraceDetail", isV4 },
+ scoreMetadata: { projectId, environment },
+ } satisfies AnnotationPanelData;
+}
diff --git a/web/src/features/sessions/SessionReviewWorkspace.clienttest.tsx b/web/src/features/sessions/SessionReviewWorkspace.clienttest.tsx
index e4e2f904c9..bc1eadf952 100644
--- a/web/src/features/sessions/SessionReviewWorkspace.clienttest.tsx
+++ b/web/src/features/sessions/SessionReviewWorkspace.clienttest.tsx
@@ -1,5 +1,6 @@
/** @vitest-environment jsdom */
import { useState, type ReactNode } from "react";
+import type * as ResizablePanels from "react-resizable-panels";
import {
act,
cleanup,
@@ -22,7 +23,9 @@ const { groupRef, router } = vi.hoisted(() => ({
}));
vi.mock("next/router", () => ({ useRouter: () => router }));
-vi.mock("react-resizable-panels", () => ({
+vi.mock("@/src/features/rbac", () => ({ useHasProjectAccess: () => true }));
+vi.mock("react-resizable-panels", async (importOriginal) => ({
+ ...(await importOriginal<typeof ResizablePanels>()),
useGroupRef: () => groupRef,
Group: ({
children,
diff --git a/web/src/features/sessions/SessionReviewWorkspace.tsx b/web/src/features/sessions/SessionReviewWorkspace.tsx
index f77c60a8d4..c6351b8c71 100644
--- a/web/src/features/sessions/SessionReviewWorkspace.tsx
+++ b/web/src/features/sessions/SessionReviewWorkspace.tsx
@@ -1,7 +1,7 @@
import { useLayoutEffect, useRef, useState, type ReactNode } from "react";
import { Group, Panel, Separator, useGroupRef } from "react-resizable-panels";
import { useStore } from "zustand";
-import { TraceReviewPanel } from "@/src/features/traces/components/TraceReviewPanel";
+import { SessionReviewPanel } from "@/src/features/traces/components/TraceReviewPanel";
import { useTraceReviewPanel } from "@/src/features/traces/contexts/TraceReviewPanelContext";
import { SessionReviewLeadingProvider } from "@/src/features/sessions/sessionReviewLeading";
import { useElementSize } from "@/src/hooks/useElementSize";
@@ -116,8 +116,10 @@ export function SessionReviewWorkspace({
disabled={!open}
aria-label="Resize review panel"
className={cn(
- "bg-border",
- vertical ? "h-px" : "w-px",
+ "border-border relative self-stretch",
+ vertical
+ ? "h-px min-h-px w-full border-t"
+ : "h-full w-px min-w-px border-l",
!open && "hidden",
)}
/>
@@ -128,7 +130,7 @@ export function SessionReviewWorkspace({
maxSize={open ? "75%" : "0%"}
>
<div ref={reviewRef} className="h-full min-h-0" hidden={!open}>
- <TraceReviewPanel projectId={projectId} />
+ <SessionReviewPanel projectId={projectId} />
</div>
</Panel>
</Group>
diff --git a/web/src/features/traces/components/ObservationDetailView/components/ObservationDetailViewHeader/ObservationDetailViewHeader.tsx b/web/src/features/traces/components/ObservationDetailView/components/ObservationDetailViewHeader/ObservationDetailViewHeader.tsx
index c331c6daee..defab43934 100644
--- a/web/src/features/traces/components/ObservationDetailView/components/ObservationDetailViewHeader/ObservationDetailViewHeader.tsx
+++ b/web/src/features/traces/components/ObservationDetailView/components/ObservationDetailViewHeader/ObservationDetailViewHeader.tsx
@@ -1,3 +1,5 @@
+import { useTraceData } from "@/src/features/traces/contexts/TraceDataContext";
+import { prepareTraceAnnotation } from "@/src/features/scores/lib/prepareTraceAnnotation";
/**
* ObservationDetailViewHeader - Extracted header component for ObservationDetailView
*
@@ -9,7 +11,7 @@
* Memoized to prevent unnecessary re-renders when tab state changes.
*/
-import { memo, useMemo, useRef } from "react";
+import { memo, useRef } from "react";
import {
type ObservationType,
isGenerationLike,
@@ -44,7 +46,6 @@ import type Decimal from "decimal.js";
import { ConnectedDetailHeaderActionsMenuController } from "@/src/features/traces/components/DetailHeaderActionsMenuController";
import { useViewPreferences } from "@/src/features/traces/contexts/ViewPreferencesContext";
import { useReadPath } from "@/src/features/events";
-import { useTraceData } from "@/src/features/traces/contexts/TraceDataContext";
import { Button } from "@/src/components/ui/button";
import { ActionButtonCountBadge } from "@/src/components/ui/action-button-count-badge";
import {
@@ -101,6 +102,7 @@ export const ObservationDetailViewHeader = memo(
subtreeMetrics,
treeNodeTotalCost,
}: ObservationDetailViewHeaderProps) {
+ const { trace, serverScores } = useTraceData();
const { isAnnotationMode } = useViewPreferences();
const isMobile = useIsMobile();
const mobileActionsTriggerRef = useRef<HTMLButtonElement>(null);
@@ -110,13 +112,12 @@ export const ObservationDetailViewHeader = memo(
? `${commentActionLabel} (${commentCount})`
: commentActionLabel;
const { isV4: isV4Enabled } = useReadPath();
- const { trace, serverScores } = useTraceData();
-
- // Get trace-level scores for V4 dual annotation
- const traceScores = useMemo(
- () => serverScores.filter((s) => !s.observationId),
- [serverScores],
- );
+ const companionTrace = isV4Enabled
+ ? {
+ environment: trace.environment,
+ scores: serverScores.filter((score) => !score.observationId),
+ }
+ : undefined;
// Format cost and usage values
const totalCost = observation.totalCost;
@@ -259,28 +260,16 @@ export const ObservationDetailViewHeader = memo(
preventScroll: true,
});
openDrawer({
- scoreTarget: {
- type: "trace",
+ ...prepareTraceAnnotation({
traceId,
- observationId: observation.id,
- },
- scores: observationScores,
- companionTrace: isV4Enabled
- ? {
- environment: trace.environment,
- scores: traceScores,
- }
- : undefined,
- analyticsData: {
- type: "trace",
- source: "TraceDetail",
- isV4: isV4Enabled,
- },
- scoreMetadata: {
projectId,
environment:
observation.environment,
- },
+ observationId: observation.id,
+ scores: observationScores,
+ isV4: isV4Enabled,
+ }),
+ companionTrace,
});
},
},
@@ -390,27 +379,15 @@ export const ObservationDetailViewHeader = memo(
disabled={disabled}
onClick={() =>
openDrawer({
- scoreTarget: {
- type: "trace",
+ ...prepareTraceAnnotation({
traceId,
- observationId: observation.id,
- },
- scores: observationScores,
- companionTrace: isV4Enabled
- ? {
- environment: trace.environment,
- scores: traceScores,
- }
- : undefined,
- analyticsData: {
- type: "trace",
- source: "TraceDetail",
- isV4: isV4Enabled,
- },
- scoreMetadata: {
projectId,
environment: observation.environment,
- },
+ observationId: observation.id,
+ scores: observationScores,
+ isV4: isV4Enabled,
+ }),
+ companionTrace,
})
}
>
diff --git a/web/src/features/traces/components/Trace.tsx b/web/src/features/traces/components/Trace.tsx
index 57dfbeecbe..747873025b 100644
--- a/web/src/features/traces/components/Trace.tsx
+++ b/web/src/features/traces/components/Trace.tsx
@@ -30,14 +30,11 @@ import { useTraceComments } from "@/src/features/traces/hooks/useTraceComments";
import { TraceGraphView } from "@/src/features/traces/components/TraceGraphView/TraceGraphView";
import { useMemo, type ReactNode } from "react";
-import { useStore } from "zustand";
import { useRouter } from "next/router";
import { getCommentDrawerInitialStateFromUrl } from "@/src/features/comments/CommentDrawerController";
-import {
- TraceReviewPanelProvider,
- useTraceReviewPanel,
-} from "@/src/features/traces/contexts/TraceReviewPanelContext";
+import { TraceReviewPanelProvider } from "@/src/features/traces/contexts/TraceReviewPanelContext";
import { TraceReviewPanel } from "./TraceReviewPanel";
+import { useHasProjectAccess } from "@/src/features/rbac";
export type TraceProps = {
observations: Array<ObservationReturnTypeWithMetadata>;
@@ -240,6 +237,30 @@ function DesktopTraceContent({
key={`${trace.projectId}:${trace.id}`}
projectId={trace.projectId}
initialComments={getCommentDrawerInitialStateFromUrl(router.query)}
+ onOpen={(panel, target) => {
+ const {
+ annotation,
+ comments,
+ commentObjectId,
+ commentObjectType,
+ ...query
+ } = router.query;
+ router.replace(
+ {
+ pathname: router.pathname,
+ query: {
+ ...query,
+ [panel]: "open",
+ ...(target && {
+ commentObjectId: target.objectId,
+ commentObjectType: target.objectType,
+ }),
+ },
+ },
+ undefined,
+ { shallow: true },
+ );
+ }}
>
<DesktopTraceReviewWorkspace
desktopLayout={desktopLayout}
@@ -256,8 +277,10 @@ function DesktopTraceReviewWorkspace({
desktopLayout: DesktopLayout;
projectId: string;
}) {
- const store = useTraceReviewPanel();
- const reviewOpen = useStore(store, (state) => state.active !== null);
+ const { query } = useRouter();
+ const canAnnotate = useHasProjectAccess({ projectId, scope: "scores:CUD" });
+ const reviewOpen =
+ (query.annotation === "open" && canAnnotate) || query.comments === "open";
return (
<DesktopTraceWorkspace
desktopLayout={desktopLayout}
diff --git a/web/src/features/traces/components/TraceDetailView/components/TraceDetailViewHeader.tsx b/web/src/features/traces/components/TraceDetailView/components/TraceDetailViewHeader.tsx
index ee2484d5e7..5e3a470161 100644
--- a/web/src/features/traces/components/TraceDetailView/components/TraceDetailViewHeader.tsx
+++ b/web/src/features/traces/components/TraceDetailView/components/TraceDetailViewHeader.tsx
@@ -1,3 +1,4 @@
+import { prepareTraceAnnotation } from "@/src/features/scores/lib/prepareTraceAnnotation";
/**
* TraceDetailViewHeader - Extracted header component for TraceDetailView
*
@@ -172,22 +173,15 @@ export const TraceDetailViewHeader = memo(function TraceDetailViewHeader({
mobileActionsTriggerRef.current?.focus({
preventScroll: true,
});
- openDrawer({
- scoreTarget: {
- type: "trace",
+ openDrawer(
+ prepareTraceAnnotation({
traceId: trace.id,
- },
- scores: traceScores,
- analyticsData: {
- type: "trace",
- source: "TraceDetail",
- isV4,
- },
- scoreMetadata: {
projectId,
environment: trace.environment,
- },
- });
+ scores: traceScores,
+ isV4,
+ }),
+ );
},
},
]
@@ -282,22 +276,15 @@ export const TraceDetailViewHeader = memo(function TraceDetailViewHeader({
size="sm"
disabled={disabled}
onClick={() =>
- openDrawer({
- scoreTarget: {
- type: "trace",
+ openDrawer(
+ prepareTraceAnnotation({
traceId: trace.id,
- },
- scores: traceScores,
- analyticsData: {
- type: "trace",
- source: "TraceDetail",
- isV4,
- },
- scoreMetadata: {
projectId,
environment: trace.environment,
- },
- })
+ scores: traceScores,
+ isV4,
+ }),
+ )
}
>
{disabled ? (
diff --git a/web/src/features/traces/components/TraceLayoutDesktop.tsx b/web/src/features/traces/components/TraceLayoutDesktop.tsx
index 2e3363ebe5..72809b4876 100644
--- a/web/src/features/traces/components/TraceLayoutDesktop.tsx
+++ b/web/src/features/traces/components/TraceLayoutDesktop.tsx
@@ -1,3 +1,4 @@
+import { useRouter } from "next/router";
import { StringParam, useQueryParam } from "use-query-params";
import {
Group,
@@ -185,9 +186,16 @@ type TraceLayoutDesktopProps = {
};
export function TraceLayoutDesktop(props: TraceLayoutDesktopProps) {
+ const router = useRouter();
const { reviewPanel, ...layoutProps } = props;
return (
- <TraceReviewLayout open={props.reviewOpen} review={reviewPanel}>
+ <TraceReviewLayout
+ open={props.reviewOpen}
+ review={reviewPanel}
+ collapseNavigationOnEntry={
+ router.query.annotation === "open" ? true : undefined
+ }
+ >
{({ collapsed, toggle }) => (
<TraceNavigationDetailLayout
{...layoutProps}
diff --git a/web/src/features/traces/components/TraceReviewLayout.clienttest.tsx b/web/src/features/traces/components/TraceReviewLayout.clienttest.tsx
index 3a168969d7..c024c1ced2 100644
--- a/web/src/features/traces/components/TraceReviewLayout.clienttest.tsx
+++ b/web/src/features/traces/components/TraceReviewLayout.clienttest.tsx
@@ -50,11 +50,18 @@ vi.mock("react-resizable-panels", () => ({
Separator: () => <div />,
}));
-function Harness({ open = true }: { open?: boolean }) {
+function Harness({
+ open = true,
+ collapseNavigationOnEntry,
+}: {
+ open?: boolean;
+ collapseNavigationOnEntry?: boolean;
+}) {
return (
<div data-peek-content>
<TraceReviewLayout
open={open}
+ collapseNavigationOnEntry={collapseNavigationOnEntry}
review={<input aria-label="Review draft" />}
>
{({ collapsed, toggle }) => (
@@ -198,3 +205,19 @@ describe("trace review responsive workspace", () => {
);
});
});
+
+it("collapses on annotation entry while preserving manual expansion until the next entry", () => {
+ localStorage.setItem("trace-review-navigation-collapsed", "false");
+ const view = render(<Harness collapseNavigationOnEntry />);
+ fireEvent.click(screen.getByRole("button", { name: "Show navigation" }));
+ view.rerender(<Harness collapseNavigationOnEntry />);
+ expect(
+ screen.getByRole("button", { name: "Hide navigation" }),
+ ).toBeInTheDocument();
+
+ view.rerender(<Harness open={false} />);
+ view.rerender(<Harness collapseNavigationOnEntry />);
+ expect(
+ screen.getByRole("button", { name: "Show navigation" }),
+ ).toBeInTheDocument();
+});
diff --git a/web/src/features/traces/components/TraceReviewLayout.stories.tsx b/web/src/features/traces/components/TraceReviewLayout.stories.tsx
index b0cc164326..e397cd4740 100644
--- a/web/src/features/traces/components/TraceReviewLayout.stories.tsx
+++ b/web/src/features/traces/components/TraceReviewLayout.stories.tsx
@@ -30,3 +30,19 @@ export const ThreePaneReview = meta.story({
review: <div className="h-full p-4">Annotate</div>,
},
});
+
+export const CollapsedNavigation = meta.story({
+ args: {
+ open: true,
+ collapseNavigationOnEntry: true,
+ children: () => (
+ <div className="h-full p-4">Observation input and output</div>
+ ),
+ review: <div className="h-full p-4">Annotation scores</div>,
+ },
+ render: (args) => (
+ <div className="h-[36rem] w-[50rem] overflow-hidden border">
+ <TraceReviewLayout {...args} />
+ </div>
+ ),
+});
diff --git a/web/src/features/traces/components/TraceReviewLayout.tsx b/web/src/features/traces/components/TraceReviewLayout.tsx
index 49c8d08cc1..684c1d97bb 100644
--- a/web/src/features/traces/components/TraceReviewLayout.tsx
+++ b/web/src/features/traces/components/TraceReviewLayout.tsx
@@ -20,10 +20,12 @@ function readNavigationPreference(): boolean | null {
export function TraceReviewLayout({
open,
review,
+ collapseNavigationOnEntry,
children,
}: {
open: boolean;
review: ReactNode;
+ collapseNavigationOnEntry?: boolean;
children: (navigation: {
collapsed: boolean;
toggle: () => void;
@@ -37,8 +39,15 @@ export function TraceReviewLayout({
isPeek: false,
});
const [navigationPreference, setNavigationPreference] = useState(
- readNavigationPreference,
+ () => collapseNavigationOnEntry ?? readNavigationPreference(),
);
+ const [previousEntryCollapse, setPreviousEntryCollapse] = useState(
+ collapseNavigationOnEntry,
+ );
+ if (previousEntryCollapse !== collapseNavigationOnEntry) {
+ setPreviousEntryCollapse(collapseNavigationOnEntry);
+ if (collapseNavigationOnEntry) setNavigationPreference(true);
+ }
useLayoutEffect(() => {
const root = rootRef.current;
@@ -136,8 +145,10 @@ export function TraceReviewLayout({
disabled={!open}
aria-label="Resize review panel"
className={cn(
- "bg-border",
- vertical ? "h-px" : "w-px",
+ "border-border relative self-stretch",
+ vertical
+ ? "h-px min-h-px w-full border-t"
+ : "h-full w-px min-w-px border-l",
!open && "hidden",
)}
/>
diff --git a/web/src/features/traces/components/TraceReviewPanel.clienttest.tsx b/web/src/features/traces/components/TraceReviewPanel.clienttest.tsx
new file mode 100644
index 0000000000..f639811417
--- /dev/null
+++ b/web/src/features/traces/components/TraceReviewPanel.clienttest.tsx
@@ -0,0 +1,114 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+import { createTraceReviewPanelStore } from "../state/traceReviewPanelStore";
+import { TraceReviewPanel } from "./TraceReviewPanel";
+
+const state = vi.hoisted(() => ({
+ query: { annotation: "open" } as Record<string, string>,
+ selectedNodeId: "first",
+ replace: vi.fn(),
+}));
+const store = createTraceReviewPanelStore({
+ projectId: "project",
+});
+vi.mock("next/router", () => ({
+ useRouter: () => ({
+ query: state.query,
+ pathname: "/trace",
+ replace: state.replace,
+ }),
+}));
+vi.mock("../contexts/TraceReviewPanelContext", () => ({
+ useTraceReviewPanel: () => store,
+}));
+vi.mock("../contexts/SelectionContext", () => ({
+ useSelection: () => ({ selectedNodeId: state.selectedNodeId }),
+}));
+vi.mock("../contexts/TraceDataContext", () => ({
+ useTraceData: () => ({
+ trace: { id: "trace", projectId: "project", environment: "default" },
+ observations: [
+ { id: "first", environment: "default" },
+ { id: "second", environment: "default" },
+ ],
+ serverScores: [
+ { id: "trace-score", observationId: null },
+ { id: "first-score", observationId: "first" },
+ { id: "second-score", observationId: "second" },
+ ],
+ }),
+}));
+vi.mock("@/src/features/events", () => ({
+ useReadPath: () => ({ isV4: true }),
+}));
+vi.mock("@/src/features/rbac", () => ({ useHasProjectAccess: () => true }));
+vi.mock("@/src/features/scores/components/AnnotationPanelContent", () => ({
+ AnnotationPanelContent: ({
+ data,
+ }: {
+ data: {
+ scoreTarget: { observationId?: string };
+ scores: { id: string }[];
+ companionTrace?: { scores: { id: string }[] };
+ };
+ }) => (
+ <div data-testid="annotation">
+ {data.scoreTarget.observationId ?? "trace"}:
+ {data.scores.map((score) => score.id).join(",")}
+ <span data-testid="trace-scope">
+ {data.companionTrace?.scores.map((score) => score.id).join(",")}
+ </span>
+ </div>
+ ),
+}));
+vi.mock("@/src/features/comments/CommentList", () => ({
+ CommentList: ({ objectId }: { objectId: string }) => (
+ <div data-testid="comments">{objectId}</div>
+ ),
+}));
+vi.mock("@/src/features/comments/CommentDrawerController", () => ({
+ getCommentDrawerInitialStateFromUrl: () => undefined,
+}));
+
+it("follows the selected annotation target and switches panels through the URL", () => {
+ const view = render(<TraceReviewPanel projectId="project" />);
+ expect(screen.getByTestId("annotation")).toHaveTextContent(
+ "first:first-score",
+ );
+ expect(screen.getByTestId("trace-scope")).toHaveTextContent("trace-score");
+ state.selectedNodeId = "second";
+ view.rerender(<TraceReviewPanel projectId="project" />);
+ expect(screen.getByTestId("annotation")).toHaveTextContent(
+ "second:second-score",
+ );
+ expect(screen.getByTestId("trace-scope")).toHaveTextContent("trace-score");
+ expect(screen.getByTestId("annotation")).not.toHaveTextContent("first-score");
+ state.selectedNodeId = "trace";
+ view.rerender(<TraceReviewPanel projectId="project" />);
+ expect(screen.getByTestId("annotation")).toHaveTextContent(
+ "trace:trace-score",
+ );
+ state.query = { comments: "open" };
+ view.rerender(<TraceReviewPanel projectId="project" />);
+ expect(screen.getByTestId("comments")).toHaveTextContent("trace");
+ expect(screen.queryByTestId("annotation")).not.toBeInTheDocument();
+ state.query = { annotation: "open" };
+ view.rerender(<TraceReviewPanel projectId="project" />);
+ expect(screen.getByTestId("annotation")).toHaveTextContent(
+ "trace:trace-score",
+ );
+});
+
+it("closes comment deep links with Escape and clears their URL target", () => {
+ state.query = {
+ comments: "open",
+ commentObjectId: "trace",
+ commentObjectType: "TRACE",
+ };
+ render(<TraceReviewPanel projectId="project" />);
+ fireEvent.keyDown(document.body, { key: "Escape" });
+ expect(state.replace).toHaveBeenCalledWith(
+ { pathname: "/trace", query: {} },
+ undefined,
+ { shallow: true },
+ );
+});
diff --git a/web/src/features/traces/components/TraceReviewPanel.tsx b/web/src/features/traces/components/TraceReviewPanel.tsx
index cbab1d403d..9b82177629 100644
--- a/web/src/features/traces/components/TraceReviewPanel.tsx
+++ b/web/src/features/traces/components/TraceReviewPanel.tsx
@@ -1,5 +1,13 @@
+import { type AnnotationPanelData } from "@/src/features/scores/types";
+import { type CommentTarget } from "@/src/features/comments/state/commentOverlayStore";
+import { getCommentDrawerInitialStateFromUrl } from "@/src/features/comments/CommentDrawerController";
+import { useHasProjectAccess } from "@/src/features/rbac";
+import { useTraceData } from "../contexts/TraceDataContext";
+import { useSelection } from "../contexts/SelectionContext";
+import { useReadPath } from "@/src/features/events";
+import { prepareTraceAnnotation } from "@/src/features/scores/lib/prepareTraceAnnotation";
import { useStore } from "zustand";
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, type ReactNode } from "react";
import { useRouter, type NextRouter } from "next/router";
import { X } from "lucide-react";
import { Button } from "@/src/components/ui/button";
@@ -11,8 +19,9 @@ import { type TraceReviewPanelStore } from "../state/traceReviewPanelStore";
function closeReviewPanel(store: TraceReviewPanelStore, router: NextRouter) {
store.getState().actions.close();
- if (router.query.comments !== "open") return;
- const { comments, commentObjectType, commentObjectId, ...query } =
+ if (router.query.comments !== "open" && router.query.annotation !== "open")
+ return;
+ const { comments, commentObjectType, commentObjectId, annotation, ...query } =
router.query;
router.replace({ pathname: router.pathname, query }, undefined, {
shallow: true,
@@ -36,13 +45,43 @@ function CloseReviewPanelButton() {
function TraceCommentsPanel({ projectId }: { projectId: string }) {
const store = useTraceReviewPanel();
- const target = useStore(store, (state) => state.comments!.target);
- const sessionKey = useStore(store, (state) => state.comments!.key);
- const onCommentChange = useStore(
- store,
- (state) => state.comments!.onCommentChange,
+ const router = useRouter();
+ const { trace, observations } = useTraceData();
+ const { selectedNodeId } = useSelection();
+ const observation = observations.find((item) => item.id === selectedNodeId);
+ const session = useStore(store, (state) => state.comments);
+ const active =
+ router.query.comments === "open" && router.query.annotation !== "open";
+ const target: CommentTarget = (!active ? session?.target : undefined) ??
+ getCommentDrawerInitialStateFromUrl(router.query) ?? {
+ type: "comments" as const,
+ objectId: observation?.id ?? trace.id,
+ objectType: observation ? ("OBSERVATION" as const) : ("TRACE" as const),
+ objectStartTime: observation?.startTime ?? trace.timestamp,
+ };
+ return (
+ <CommentsPanel projectId={projectId} target={target} active={active} />
);
- const active = useStore(store, (state) => state.active === "comments");
+}
+
+function CommentsPanel({
+ projectId,
+ target,
+ active,
+}: {
+ projectId: string;
+ target: CommentTarget;
+ active: boolean;
+}) {
+ const store = useTraceReviewPanel();
+ const session = useStore(store, (state) => state.comments);
+ const matchingSession =
+ session?.target.objectId === target.objectId &&
+ session.target.objectType === target.objectType
+ ? session
+ : null;
+ const sessionKey = matchingSession?.key ?? -1;
+ const onCommentChange = matchingSession?.onCommentChange;
const actions = store.getState().actions;
return (
<section
@@ -56,12 +95,17 @@ function TraceCommentsPanel({ projectId }: { projectId: string }) {
</div>
<div className="min-h-0 flex-1">
<CommentList
+ key={`${target.objectType}:${target.objectId}`}
projectId={projectId}
objectId={target.objectId}
objectType={target.objectType}
- objectStartTime={target.objectStartTime}
+ objectStartTime={
+ matchingSession?.target.objectStartTime ?? target.objectStartTime
+ }
pendingSelection={
- target.type === "inline-comment" ? target.selection : null
+ matchingSession?.target.type === "inline-comment"
+ ? matchingSession.target.selection
+ : null
}
onSelectionUsed={() => actions.consumeCommentsSelection(sessionKey)}
onDraftChange={(hasDraft) =>
@@ -80,9 +124,52 @@ function TraceCommentsPanel({ projectId }: { projectId: string }) {
}
function TraceAnnotationPanel() {
+ const { trace, observations, serverScores } = useTraceData();
+ const { selectedNodeId } = useSelection();
+ const { isV4 } = useReadPath();
+ const observation = observations.find((item) => item.id === selectedNodeId);
+ const active = useRouter().query.annotation === "open";
+ if (selectedNodeId && selectedNodeId !== trace.id && !observation) {
+ return (
+ <div className="p-4 text-sm" hidden={!active}>
+ Loading annotation…
+ </div>
+ );
+ }
+ const data = prepareTraceAnnotation({
+ traceId: trace.id,
+ projectId: trace.projectId,
+ environment: observation?.environment ?? trace.environment,
+ observationId: observation?.id,
+ scores: serverScores,
+ isV4,
+ });
+ return (
+ <AnnotationPanel
+ key={observation?.id ?? trace.id}
+ data={{
+ ...data,
+ companionTrace:
+ observation && isV4
+ ? {
+ environment: trace.environment,
+ scores: serverScores.filter((score) => !score.observationId),
+ }
+ : undefined,
+ }}
+ active={active}
+ />
+ );
+}
+
+function AnnotationPanel({
+ data,
+ active,
+}: {
+ data: AnnotationPanelData;
+ active: boolean;
+}) {
const store = useTraceReviewPanel();
- const annotation = useStore(store, (state) => state.annotation!);
- const active = useStore(store, (state) => state.active === "annotate");
return (
<section
aria-label="Annotate"
@@ -90,7 +177,7 @@ function TraceAnnotationPanel() {
hidden={!active}
>
<AnnotationPanelContent
- data={annotation.data}
+ data={data}
refreshRef={store.annotationFormRef}
actionButtons={<CloseReviewPanelButton />}
isActive={active}
@@ -101,10 +188,63 @@ function TraceAnnotationPanel() {
export function TraceReviewPanel({ projectId }: { projectId: string }) {
const store = useTraceReviewPanel();
- const rootRef = useRef<HTMLDivElement>(null);
- const active = useStore(store, (state) => state.active);
const commentsKey = useStore(store, (state) => state.comments?.key);
- const annotationKey = useStore(store, (state) => state.annotation?.key);
+ const hasAnnotation = useStore(store, (state) => state.annotation !== null);
+ const { query } = useRouter();
+ const canAnnotate = useHasProjectAccess({ projectId, scope: "scores:CUD" });
+ const annotationOpen = query.annotation === "open" && canAnnotate;
+ return (
+ <ReviewPanel
+ active={
+ annotationOpen ? "annotate" : query.comments === "open" && "comments"
+ }
+ >
+ {(commentsKey !== undefined || query.comments === "open") && (
+ <TraceCommentsPanel key={commentsKey} projectId={projectId} />
+ )}
+ {canAnnotate && (hasAnnotation || annotationOpen) && (
+ <TraceAnnotationPanel />
+ )}
+ </ReviewPanel>
+ );
+}
+
+export function SessionReviewPanel({ projectId }: { projectId: string }) {
+ const store = useTraceReviewPanel();
+ const active = useStore(store, (state) => state.active);
+ const comments = useStore(store, (state) => state.comments);
+ const annotation = useStore(store, (state) => state.annotation);
+ const canAnnotate = useHasProjectAccess({ projectId, scope: "scores:CUD" });
+ return (
+ <ReviewPanel active={active}>
+ {comments && (
+ <CommentsPanel
+ key={comments.key}
+ projectId={projectId}
+ target={comments.target}
+ active={active === "comments"}
+ />
+ )}
+ {annotation && canAnnotate && (
+ <AnnotationPanel
+ key={annotation.key}
+ data={annotation.data}
+ active={active === "annotate"}
+ />
+ )}
+ </ReviewPanel>
+ );
+}
+
+function ReviewPanel({
+ active,
+ children,
+}: {
+ active: "annotate" | "comments" | false | null;
+ children: ReactNode;
+}) {
+ const store = useTraceReviewPanel();
+ const rootRef = useRef<HTMLDivElement>(null);
const router = useRouter();
useEffect(() => {
@@ -143,12 +283,7 @@ export function TraceReviewPanel({ projectId }: { projectId: string }) {
className="bg-background h-full min-h-0 overflow-hidden"
data-trace-review-panel
>
- {commentsKey !== undefined ? (
- <TraceCommentsPanel key={commentsKey} projectId={projectId} />
- ) : null}
- {annotationKey !== undefined ? (
- <TraceAnnotationPanel key={annotationKey} />
- ) : null}
+ {children}
</div>
);
}
diff --git a/web/src/features/traces/contexts/TraceReviewPanelContext.tsx b/web/src/features/traces/contexts/TraceReviewPanelContext.tsx
index b825c0a9e0..d7ae9b3c25 100644
--- a/web/src/features/traces/contexts/TraceReviewPanelContext.tsx
+++ b/web/src/features/traces/contexts/TraceReviewPanelContext.tsx
@@ -5,6 +5,15 @@ import {
type TraceReviewPanelStore,
} from "../state/traceReviewPanelStore";
+const ReviewPanelOpenContext = createContext<
+ | ((panel: "annotation" | "comments", target?: CommentTarget) => void)
+ | undefined
+>(undefined);
+
+export function useReviewPanelOpen() {
+ return useContext(ReviewPanelOpenContext);
+}
+
const TraceReviewPanelContext = createContext<TraceReviewPanelStore | null>(
null,
);
@@ -12,19 +21,26 @@ const TraceReviewPanelContext = createContext<TraceReviewPanelStore | null>(
export function TraceReviewPanelProvider({
projectId,
initialComments,
+ onOpen,
children,
}: {
projectId: string;
initialComments?: CommentTarget;
+ onOpen?: (panel: "annotation" | "comments", target?: CommentTarget) => void;
children: ReactNode;
}) {
const [store] = useState(() =>
- createTraceReviewPanelStore({ projectId, initialComments }),
+ createTraceReviewPanelStore({
+ projectId,
+ initialComments,
+ }),
);
return (
<TraceReviewPanelContext.Provider value={store}>
- {children}
+ <ReviewPanelOpenContext.Provider value={onOpen}>
+ {children}
+ </ReviewPanelOpenContext.Provider>
</TraceReviewPanelContext.Provider>
);
}