Skip to content

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

feat(web): Allow users to toggle session timeline (#17424)

Ben Bachemc1a4cc731ba5
diff --git a/web/src/__tests__/server/organization-feature-flags.servertest.ts b/web/src/__tests__/server/organization-feature-flags.servertest.ts
index 44b1ba36a6..0b0c6bf326 100644
--- a/web/src/__tests__/server/organization-feature-flags.servertest.ts
+++ b/web/src/__tests__/server/organization-feature-flags.servertest.ts
@@ -61,6 +61,29 @@ describe("organization feature preview defaults", () => {
});
});
+ it("enables the Compact Session default with the Session Timeline default", async () => {
+ const { actor, caller, org } = await prepare();
+ await prisma.user.update({
+ where: { id: actor.id },
+ data: { featureFlags: ["modernSession", "sessionTimeline"] },
+ });
+
+ await caller.organizations.setFeatureFlagOrgDefault({
+ orgId: org.id,
+ flag: "sessionTimeline",
+ enabled: true,
+ });
+
+ await expect(
+ prisma.organization.findUniqueOrThrow({
+ where: { id: org.id },
+ select: { featureFlagOrgDefaults: true },
+ }),
+ ).resolves.toEqual({
+ featureFlagOrgDefaults: ["sessionTimeline", "modernSession"],
+ });
+ });
+
it("allows tested administrators and rejects ordinary organization members", async () => {
const admin = await prepare("cloud:core", Role.ADMIN);
await prisma.user.update({
@@ -209,6 +232,7 @@ describe("organization feature preview defaults", () => {
// here. Asserting that two REGISTERED defaults resolve differently needs
// a second preview; add that half back with the next one.
modernSession: false,
+ sessionTimeline: false,
normalizedIoPreview: false,
});
});
@@ -242,6 +266,30 @@ describe("organization feature preview defaults", () => {
});
describe("organization member feature preview overrides", () => {
+ it("enables Compact Session when enabling Session Timeline for a member", async () => {
+ const { caller, org } = await prepare();
+ const target = await createUser();
+ await prisma.organizationMembership.create({
+ data: { orgId: org.id, userId: target.id, role: Role.MEMBER },
+ });
+
+ await caller.members.setUserFeaturePreviewEnabled({
+ orgId: org.id,
+ userId: target.id,
+ flag: "sessionTimeline",
+ enabled: true,
+ });
+
+ await expect(
+ prisma.user.findUniqueOrThrow({
+ where: { id: target.id },
+ select: { featureFlags: true },
+ }),
+ ).resolves.toEqual({
+ featureFlags: ["sessionTimeline", "modernSession"],
+ });
+ });
+
it("persists an administrator's disable as a global user opt-out", async () => {
const { caller, org } = await prepare();
const target = await createUser({ featureFlags: ["modernSession"] });
@@ -262,7 +310,10 @@ describe("organization member feature preview overrides", () => {
select: { featureFlags: true },
}),
).resolves.toEqual({
- featureFlags: [getFeaturePreviewOptOutFlag("modernSession")],
+ featureFlags: [
+ getFeaturePreviewOptOutFlag("modernSession"),
+ getFeaturePreviewOptOutFlag("sessionTimeline"),
+ ],
});
});
@@ -442,6 +493,7 @@ describe("organization member feature preview overrides", () => {
// hidden, which is what this guards.
expect(row?.featurePreviews).toEqual({
modernSession: true,
+ sessionTimeline: false,
normalizedIoPreview: false,
});
expect(row?.user).not.toHaveProperty("featureFlags");
diff --git a/web/src/__tests__/server/userAccount.servertest.ts b/web/src/__tests__/server/userAccount.servertest.ts
index 327d6f6f12..aad1019fe5 100644
--- a/web/src/__tests__/server/userAccount.servertest.ts
+++ b/web/src/__tests__/server/userAccount.servertest.ts
@@ -45,6 +45,25 @@ describe("userAccountRouter.setFeaturePreviewEnabled", () => {
expect(user.featureFlags).toEqual(["templateFlag", "modernSession"]);
});
+ it("allows users to enable the session timeline preview", async () => {
+ const { caller, userId } = await createCaller();
+
+ await caller.userAccount.setFeaturePreviewEnabled({
+ flag: "sessionTimeline",
+ enabled: true,
+ });
+
+ const user = await prisma.user.findUniqueOrThrow({
+ where: { id: userId },
+ select: { featureFlags: true },
+ });
+ expect(user.featureFlags).toEqual([
+ "templateFlag",
+ "sessionTimeline",
+ "modernSession",
+ ]);
+ });
+
it("persists a global opt-out when disabling a preview", async () => {
const { caller, userId } = await createCaller({
featureFlags: ["templateFlag", "modernSession"],
@@ -68,6 +87,7 @@ describe("userAccountRouter.setFeaturePreviewEnabled", () => {
expect(user.featureFlags).toEqual([
"templateFlag",
getFeaturePreviewOptOutFlag("modernSession"),
+ getFeaturePreviewOptOutFlag("sessionTimeline"),
]);
});
@@ -207,6 +227,7 @@ async function createCaller({
],
featureFlags: {
modernSession: featureFlags.includes("modernSession"),
+ sessionTimeline: featureFlags.includes("sessionTimeline"),
searchBar: featureFlags.includes("searchBar"),
templateFlag: featureFlags.includes("templateFlag"),
excludeClickhouseRead: false,
diff --git a/web/src/features/feature-flags/available-flags.ts b/web/src/features/feature-flags/available-flags.ts
index e08ca7ba5a..bb5eb37f00 100644
--- a/web/src/features/feature-flags/available-flags.ts
+++ b/web/src/features/feature-flags/available-flags.ts
@@ -2,6 +2,7 @@ import { assertUnreachable } from "@langfuse/shared";
export const featurePreviewFlags = [
"modernSession",
+ "sessionTimeline",
"normalizedIoPreview",
] as const;
@@ -25,6 +26,7 @@ export const filterFeaturePreviewFlags = (
export const featurePreviewLabels = {
modernSession: "Compact Session View",
+ sessionTimeline: "Session Timeline",
normalizedIoPreview: "Improved Message Rendering",
} satisfies Record<FeaturePreviewFlag, string>;
@@ -36,7 +38,7 @@ export const isFeaturePreviewAvailable = (
flag: FeaturePreviewFlag,
context: FeaturePreviewAvailabilityContext,
) => {
- if (flag === "modernSession") {
+ if (flag === "modernSession" || flag === "sessionTimeline") {
return context.v4BetaEnabled;
}
@@ -56,7 +58,4 @@ export const availableFlags = [
"v4BetaToggleVisible",
"observationEvals",
"experimentsV4Enabled",
- // Internal flag (deliberately NOT in featurePreviewFlags): gates the
- // redesigned compact session timeline for admins/flagged users only.
- "sessionTimeline",
] as const;
diff --git a/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsx b/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsx
index 414065b075..628661d1b8 100644
--- a/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsx
+++ b/web/src/features/feature-flags/components/OrganizationFeaturePreviewsSettings.clienttest.tsx
@@ -170,6 +170,11 @@ describe("OrganizationFeaturePreviewsSettings", () => {
// Derived, not hardcoded: the page renders one switch per registered
// preview, so a new preview must not fail this test.
expect(switches).toHaveLength(featurePreviewFlags.length);
+ expect(
+ screen.getByRole("checkbox", {
+ name: "Toggle Session Timeline organization default",
+ }),
+ ).toBeInTheDocument();
switches.forEach((featureSwitch) => {
expect(featureSwitch).toBeChecked();
expect(featureSwitch).toBeDisabled();
diff --git a/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsx b/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsx
index a2ab007773..e5bf6d799b 100644
--- a/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsx
+++ b/web/src/features/feature-flags/components/UserFeaturePreviewsPopover.clienttest.tsx
@@ -123,6 +123,7 @@ describe("UserFeaturePreviewsControl", () => {
userId: "user-1",
featurePreviews: {
modernSession: false,
+ sessionTimeline: false,
normalizedIoPreview: false,
},
management: {
@@ -150,6 +151,7 @@ describe("UserFeaturePreviewsControl", () => {
userId: "user-1",
featurePreviews: {
modernSession: false,
+ sessionTimeline: false,
normalizedIoPreview: false,
},
management: { allowed: true },
@@ -186,6 +188,7 @@ describe("UserFeaturePreviewsControl", () => {
userId: "user-1",
featurePreviews: {
modernSession: false,
+ sessionTimeline: false,
normalizedIoPreview: false,
},
management: { allowed: true },
@@ -213,6 +216,7 @@ describe("UserFeaturePreviewsControl", () => {
userId: "user-1",
featurePreviews: {
modernSession: false,
+ sessionTimeline: false,
normalizedIoPreview: false,
},
management: { allowed: true },
diff --git a/web/src/features/feature-flags/server/organizationFeatureFlags.ts b/web/src/features/feature-flags/server/organizationFeatureFlags.ts
index f57c8769f5..afb39bd174 100644
--- a/web/src/features/feature-flags/server/organizationFeatureFlags.ts
+++ b/web/src/features/feature-flags/server/organizationFeatureFlags.ts
@@ -185,14 +185,25 @@ async function setUserFeaturePreviewInTransaction({
const user = rows[0];
if (!user) throw new LangfuseNotFoundError("User not found");
- const optOutFlag = getFeaturePreviewOptOutFlag(flag);
+ const affectedFlags: FeaturePreviewFlag[] = [flag];
+ if (flag === "sessionTimeline" && enabled) {
+ affectedFlags.push("modernSession");
+ }
+ if (flag === "modernSession" && !enabled) {
+ affectedFlags.push("sessionTimeline");
+ }
const nextFeatureFlags = user.featureFlags.filter(
- (currentFlag) => currentFlag !== flag && currentFlag !== optOutFlag,
+ (currentFlag) =>
+ !affectedFlags.some(
+ (affectedFlag) =>
+ currentFlag === affectedFlag ||
+ currentFlag === getFeaturePreviewOptOutFlag(affectedFlag),
+ ),
);
if (enabled) {
- nextFeatureFlags.push(flag);
+ nextFeatureFlags.push(...affectedFlags);
} else {
- nextFeatureFlags.push(optOutFlag);
+ nextFeatureFlags.push(...affectedFlags.map(getFeaturePreviewOptOutFlag));
}
const before = getFeaturePreviewOverrideState(user.featureFlags, flag);
@@ -310,10 +321,18 @@ export async function setOrganizationFeatureFlagDefault({
const before = filterFeaturePreviewFlags(
organization.featureFlagOrgDefaults,
);
+ const affectedFlags: FeaturePreviewFlag[] = [flag];
+ if (flag === "sessionTimeline" && enabled) {
+ affectedFlags.push("modernSession");
+ }
+ if (flag === "modernSession" && !enabled) {
+ affectedFlags.push("sessionTimeline");
+ }
const nextStoredDefaults = organization.featureFlagOrgDefaults.filter(
- (currentFlag) => currentFlag !== flag,
+ (currentFlag) =>
+ !affectedFlags.some((affectedFlag) => currentFlag === affectedFlag),
);
- if (enabled) nextStoredDefaults.push(flag);
+ if (enabled) nextStoredDefaults.push(...affectedFlags);
const after = filterFeaturePreviewFlags(nextStoredDefaults);
await tx.organization.update({
diff --git a/web/src/features/feature-flags/utils.clienttest.ts b/web/src/features/feature-flags/utils.clienttest.ts
index 7b691ede33..f40396fd06 100644
--- a/web/src/features/feature-flags/utils.clienttest.ts
+++ b/web/src/features/feature-flags/utils.clienttest.ts
@@ -69,6 +69,7 @@ describe("parseFlags", () => {
);
expect(flags.modernSession).toBe(false);
+ expect(flags.sessionTimeline).toBe(false);
// Scoped to its own flag: the opt-out is a STRING match, so a matcher that
// is too loose would take neighbouring flags down with it. A non-preview
// flag stands in for that here, which keeps the guard alive no matter how
@@ -88,6 +89,15 @@ describe("parseFlags", () => {
expect(flags.modernSession).toBe(false);
});
+ it("does not enable Session Timeline without Compact Session", () => {
+ const flags = parseFlags(["sessionTimeline"], {
+ email: "[email protected]",
+ v4BetaEnabled: true,
+ });
+
+ expect(flags.sessionTimeline).toBe(false);
+ });
+
it("applies organization defaults without overriding a global opt-out", () => {
const enabled = parseFlagsWithOrganizationDefaults([], ["modernSession"], {
@@ -103,6 +113,15 @@ describe("parseFlags", () => {
expect(optedOut.modernSession).toBe(false);
});
+ it("does not apply a Session Timeline organization default without Compact Session", () => {
+ const flags = parseFlagsWithOrganizationDefaults([], ["sessionTimeline"], {
+ email: "[email protected]",
+ v4BetaEnabled: true,
+ });
+
+ expect(flags.sessionTimeline).toBe(false);
+ });
+
it("selects flags from only the active project organization", () => {
const personalFlags = parseFlags([], {
diff --git a/web/src/features/feature-flags/utils.ts b/web/src/features/feature-flags/utils.ts
index 88ecc7b7e1..e2f032bd88 100644
--- a/web/src/features/feature-flags/utils.ts
+++ b/web/src/features/feature-flags/utils.ts
@@ -58,6 +58,10 @@ export const parseFlags = (
parsedFlags[flag] = dbFlags.includes(flag);
});
+ if (!parsedFlags.modernSession) {
+ parsedFlags.sessionTimeline = false;
+ }
+
return parsedFlags;
};
diff --git a/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx b/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx
index 4e4844c911..04d0ee6e70 100644
--- a/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx
+++ b/web/src/features/feature-previews/components/ControlledFeaturePreviewModal.tsx
@@ -44,11 +44,13 @@ export function ControlledFeaturePreviewModal({
const onToggle = (flag: PreviewFlag) => (enabled: boolean) =>
setFeaturePreviewEnabled.mutate({ flag, enabled });
+ const isModernSessionEnabled =
+ authSession.data?.user?.featureFlags.modernSession === true ||
+ authSession.data?.environment.enableExperimentalFeatures === true;
+
const state: Partial<Record<PreviewFlag, PreviewState>> = {
modernSession: {
- enabled:
- authSession.data?.user?.featureFlags.modernSession === true ||
- authSession.data?.environment.enableExperimentalFeatures === true,
+ enabled: isModernSessionEnabled,
disabled:
!isV4 ||
authSession.data?.environment.enableExperimentalFeatures === true,
@@ -60,6 +62,24 @@ export function ControlledFeaturePreviewModal({
onToggle: onToggle("modernSession"),
isToggling: setFeaturePreviewEnabled.isPending,
},
+ sessionTimeline: {
+ enabled:
+ authSession.data?.user?.featureFlags.sessionTimeline === true ||
+ authSession.data?.environment.enableExperimentalFeatures === true,
+ disabled:
+ !isV4 ||
+ !isModernSessionEnabled ||
+ authSession.data?.environment.enableExperimentalFeatures === true,
+ warningReason: !isV4
+ ? `Compact Session View is only available on the events-backed session view. Turn on ${V4_PREVIEW_LABEL} to enable it.`
+ : !isModernSessionEnabled
+ ? "Enable Compact Session View before enabling the Session Timeline."
+ : authSession.data?.environment.enableExperimentalFeatures === true
+ ? "This preview is enabled by LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES, so a per-user opt-out does not disable it."
+ : undefined,
+ onToggle: onToggle("sessionTimeline"),
+ isToggling: setFeaturePreviewEnabled.isPending,
+ },
normalizedIoPreview: {
enabled:
authSession.data?.user?.featureFlags.normalizedIoPreview === true ||
diff --git a/web/src/features/feature-previews/components/FeaturePreviewModal.clienttest.tsx b/web/src/features/feature-previews/components/FeaturePreviewModal.clienttest.tsx
new file mode 100644
index 0000000000..4e06d298fb
--- /dev/null
+++ b/web/src/features/feature-previews/components/FeaturePreviewModal.clienttest.tsx
@@ -0,0 +1,37 @@
+import { fireEvent, render, screen } from "@testing-library/react";
+
+import { FeaturePreviewModal } from "./FeaturePreviewModal";
+
+vi.mock("next/image", () => ({
+ default: ({ alt }: { alt: string }) => <span role="img" aria-label={alt} />,
+}));
+
+describe("FeaturePreviewModal", () => {
+ it("renders the session timeline toggle inside Compact Session View", () => {
+ const onTimelineToggle = vi.fn();
+
+ render(
+ <FeaturePreviewModal
+ open
+ onOpenChange={vi.fn()}
+ state={{
+ modernSession: { enabled: true, onToggle: vi.fn() },
+ sessionTimeline: {
+ enabled: false,
+ onToggle: onTimelineToggle,
+ },
+ }}
+ />,
+ );
+
+ const timelineToggle = screen.getByRole("switch", {
+ name: "Toggle Session Timeline",
+ });
+ fireEvent.click(timelineToggle);
+
+ expect(onTimelineToggle).toHaveBeenCalledWith(true);
+ expect(
+ screen.queryByRole("button", { name: /Session Timeline/ }),
+ ).not.toBeInTheDocument();
+ });
+});
diff --git a/web/src/features/feature-previews/components/FeaturePreviewModal.stories.tsx b/web/src/features/feature-previews/components/FeaturePreviewModal.stories.tsx
index fbf43e9ad2..c82bf3a272 100644
--- a/web/src/features/feature-previews/components/FeaturePreviewModal.stories.tsx
+++ b/web/src/features/feature-previews/components/FeaturePreviewModal.stories.tsx
@@ -57,6 +57,7 @@ const meta = preview.meta({
onOpenChange: fn(),
state: {
modernSession: { enabled: false, onToggle: fn(), isToggling: false },
+ sessionTimeline: { enabled: false, disabled: true, onToggle: fn() },
},
},
render: StatefulFeaturePreviewModal,
diff --git a/web/src/features/feature-previews/components/FeaturePreviewModal.tsx b/web/src/features/feature-previews/components/FeaturePreviewModal.tsx
index 4753052683..9e42e83f29 100644
--- a/web/src/features/feature-previews/components/FeaturePreviewModal.tsx
+++ b/web/src/features/feature-previews/components/FeaturePreviewModal.tsx
@@ -200,6 +200,34 @@ export function FeaturePreviewModal({
</div>
</div>
+ {selected.flag === "modernSession" && state.sessionTimeline ? (
+ <div className="border-border mt-5 flex items-start justify-between gap-6 border-t pt-5">
+ <div>
+ <h3 className="text-foreground text-sm font-bold">
+ {featurePreviewLabels.sessionTimeline}
+ </h3>
+ <p className="text-muted-foreground mt-1 max-w-2xl text-sm leading-5">
+ Use the redesigned timeline to navigate session events
+ in chronological order.
+ </p>
+ {state.sessionTimeline.warningReason ? (
+ <p className="mt-2 text-xs text-yellow-800 dark:text-yellow-200">
+ {state.sessionTimeline.warningReason}
+ </p>
+ ) : null}
+ </div>
+ <Switch
+ checked={state.sessionTimeline.enabled}
+ disabled={
+ state.sessionTimeline.disabled === true ||
+ state.sessionTimeline.isToggling === true
+ }
+ onCheckedChange={state.sessionTimeline.onToggle}
+ aria-label={`Toggle ${featurePreviewLabels.sessionTimeline}`}
+ />
+ </div>
+ ) : null}
+
<PreviewMockupPanel illustration={selected.illustration} />
<p className="text-muted-foreground mt-5 text-sm leading-5">
diff --git a/web/src/features/sessions/SessionPages.tsx b/web/src/features/sessions/SessionPages.tsx
index 7b1a45abbc..abe0908df9 100644
--- a/web/src/features/sessions/SessionPages.tsx
+++ b/web/src/features/sessions/SessionPages.tsx
@@ -995,6 +995,7 @@ const LoadedSessionEventsPage: React.FC<{
projectId,
});
const isSessionTimelineEnabled = useIsFeatureEnabled("sessionTimeline", {
+ enableForAdmins: false,
projectId,
});
const isMobile = useIsMobile();