Skip to content

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

feat(experiments): unify per-experiment filter targeting (#17944)

marliessophie748b8b39ce62
diff --git a/.agents/skills/seed-test-data/SKILL.md b/.agents/skills/seed-test-data/SKILL.md
index e2cbf4ffda..55420dfd8c 100644
--- a/.agents/skills/seed-test-data/SKILL.md
+++ b/.agents/skills/seed-test-data/SKILL.md
@@ -59,6 +59,11 @@ this.
| See all scenarios and flags | `pnpm run seed -- list --json` |
| Predict without writing | add `--dry-run` |
+For comparing filters across experiments, run `pnpm run seed -- experiment-filters`:
+three runs over 60 shared items with shifted numeric/categorical/boolean scores,
+status, item/event metadata, missing scores and missing results. Per-experiment
+expected matches are documented in `packages/shared/scripts/seeder/README.md`.
+
For a v4 experiment with chat messages and nested JSON input/output, run
`pnpm run seed -- experiment-io`. It creates one dataset, one experiment, and
three items, then prints the experiment results link. Add `--compare` for a
diff --git a/packages/shared/scripts/seeder/AGENTS.md b/packages/shared/scripts/seeder/AGENTS.md
index 37dbe8316b..d48fac19ef 100644
--- a/packages/shared/scripts/seeder/AGENTS.md
+++ b/packages/shared/scripts/seeder/AGENTS.md
@@ -32,6 +32,7 @@ pnpm run seed -- topics --batch all # 12 discovery + 3 assignment traces for To
pnpm run seed -- topics --batch evaluation --id-prefix topics-eval-s42 # 100 diverse requests, tool failures and successful outcomes
pnpm run seed -- custom-models --v4 # project-level model definitions (tiered + single-tier, one price at 0) + a trace whose generations link to them, plus one unpriced model
pnpm run seed -- experiment-io # one v4 experiment with three chat/nested JSON items for the Formatted/JSON switch
+pnpm run seed -- experiment-filters # three v4 runs over 60 items, shifted numeric/categorical/boolean scores, status, metadata and missing results
pnpm run seed -- experiment-io --compare # same dataset plus a second run with a long chat output, for the comparison table
NEXTAUTH_URL=https://pr-<N>.preview.langfuse.com pnpm run seed -- evaluator-gallery --count 200 # project-owned evaluators via the seeded public API key
```
diff --git a/packages/shared/scripts/seeder/README.md b/packages/shared/scripts/seeder/README.md
index 991d8f07e5..774f0f2b3f 100644
--- a/packages/shared/scripts/seeder/README.md
+++ b/packages/shared/scripts/seeder/README.md
@@ -63,6 +63,36 @@ Scenarios compose: e.g. a session where one trace has zero observations is
two `long-session` runs sharing a `--session-id` with different
`--id-prefix` values.
+### Experiment filter fixture
+
+`NEXTAUTH_URL=http://localhost:3010 pnpm run seed -- experiment-filters --id-prefix experiment-targets`
+creates the runs **Filter A**, **Filter B**, and **Filter C** over 60 shared
+items. Their distinct numeric `quality`, categorical `verdict`, boolean
+`approved`, status, item metadata (`category`, `cohort`) and event metadata
+(`region`, `variant`) make experiment targeting visible. Filter C omits items
+6, 12, …, 60. Each run also omits ten quality scores.
+
+For `quality > 0.8`, the per-experiment matches are:
+
+| Experiment | Matching item numbers, repeated every six items | Count |
+| ---------- | ----------------------------------------------- | ----- |
+| Filter A | 4, 5 | 20 |
+| Filter B | 2, 3 | 20 |
+| Filter C | 1 | 10 |
+
+Adding `level:ERROR` to Filter B narrows its matching items to 2, 8, …, 56
+(10 items). These are per-experiment matches; the comparison table's item
+coverage mode still determines how the sets are combined.
+
+For query-volume and suggestion-cardinality checks, use a fresh prefix:
+
+`pnpm run seed -- experiment-filters --items 12000 --extra-score-names 600 --id-prefix experiment-options-perf`
+
+This creates 34,000 events and 130,000 scores. Each event gets one additional
+numeric score, cycling through 600 names; Filter B places those scores on the
+trace, while A and C place them on the root observation. Readback verifies both
+row counts and the expected quality matches (4,000 / 4,000 / 2,000).
+
## Topics
After applying the normal Postgres and ClickHouse migrations, seed either fixture:
diff --git a/packages/shared/scripts/seeder/scenarios/experiment-filters.ts b/packages/shared/scripts/seeder/scenarios/experiment-filters.ts
new file mode 100644
index 0000000000..553f935062
--- /dev/null
+++ b/packages/shared/scripts/seeder/scenarios/experiment-filters.ts
@@ -0,0 +1,321 @@
+import { prisma } from "../../../src/db";
+import {
+ createEvent,
+ createEventsCh,
+ createScoresCh,
+ createTraceScore,
+ EventRecordInsertType,
+ ScoreRecordInsertType,
+ toClickhouseDateTime,
+} from "../../../src/server";
+import { jitter, utcDayStartMs } from "./rng";
+import { chunk, ScenarioDefinition, SeedError, SeedSummary } from "./types";
+import { countRows } from "./verify";
+
+const RUN_NAMES = ["Filter A", "Filter B", "Filter C"];
+const LEVELS = ["DEFAULT", "WARNING", "ERROR"] as const;
+const QUALITY = [0.2, 0.45, 0.65, 0.85, 0.95, null];
+const VERDICTS = ["pass", "review", "fail"];
+
+export const experimentFiltersScenario: ScenarioDefinition = {
+ name: "experiment-filters",
+ description:
+ "Three v4 experiments over 60 items, with shifted numeric, categorical and boolean scores, status and metadata. Filter C misses every sixth item; each run omits every sixth quality score.",
+ supportsV4: true,
+ flags: [
+ {
+ flag: "items",
+ type: "number",
+ default: 60,
+ description: "dataset item count (use a fresh id-prefix when changing)",
+ },
+ {
+ flag: "extra-score-names",
+ type: "number",
+ default: 0,
+ description:
+ "distinct additional score names for suggestion cardinality tests",
+ },
+ {
+ flag: "v4",
+ type: "boolean",
+ default: true,
+ description: "write v4 events (required by experiment results)",
+ },
+ ],
+ run: async (ctx, params): Promise<SeedSummary> => {
+ const startedAt = Date.now();
+ const itemCount = Number(params.items);
+ const extraScoreNames = Number(params["extra-score-names"]);
+ if (
+ !Number.isInteger(itemCount) ||
+ itemCount < 1 ||
+ !Number.isInteger(extraScoreNames) ||
+ extraScoreNames < 0
+ ) {
+ throw new SeedError(
+ "items must be positive and extra-score-names nonnegative integers",
+ );
+ }
+ const timestamp = utcDayStartMs();
+ const validFrom = new Date(0);
+ const datasetId = `${ctx.idPrefix}-dataset`;
+ const experimentIds = RUN_NAMES.map(
+ (_, index) => `${ctx.idPrefix}-run-${index + 1}`,
+ );
+ const items = Array.from({ length: itemCount }, (_, index) => ({
+ id: `${ctx.idPrefix}-item-${String(index + 1).padStart(2, "0")}`,
+ projectId: ctx.projectId,
+ datasetId,
+ validFrom,
+ input: { question: `Synthetic question ${index + 1}`, index },
+ expectedOutput: { answer: `Expected answer ${index + 1}` },
+ metadata: {
+ category: index % 2 === 0 ? "general" : "special",
+ cohort: `group-${index % 6}`,
+ },
+ }));
+ const events: EventRecordInsertType[] = [];
+ const scores: ScoreRecordInsertType[] = [];
+
+ for (const [runIndex, experimentId] of experimentIds.entries()) {
+ for (const [itemIndex, item] of items.entries()) {
+ if (runIndex === 2 && itemIndex % 6 === 5) continue;
+
+ const rowIndex = runIndex * itemCount + itemIndex;
+ const startTime =
+ timestamp + rowIndex * 1000 + jitter(ctx.seed, rowIndex, 100);
+ const traceId = `${experimentId}-trace-${itemIndex + 1}`;
+ const spanId = `${traceId}-root`;
+ const input = JSON.stringify(item.input);
+ const output = JSON.stringify({
+ answer: `Answer ${itemIndex + 1} from ${RUN_NAMES[runIndex]}`,
+ });
+ const level = LEVELS[(itemIndex + runIndex) % LEVELS.length];
+ const approved = (itemIndex + runIndex) % 2 === 0;
+ const verdictIndex = (itemIndex + runIndex) % VERDICTS.length;
+ const quality = QUALITY[(itemIndex + runIndex * 2) % QUALITY.length];
+ events.push(
+ createEvent({
+ id: spanId,
+ span_id: spanId,
+ trace_id: traceId,
+ parent_span_id: "",
+ project_id: ctx.projectId,
+ environment: ctx.environment,
+ name: `answer-${itemIndex + 1}`,
+ trace_name: `answer-${itemIndex + 1}`,
+ type: "SPAN",
+ level,
+ status_message:
+ level === "ERROR" ? "Synthetic evaluation error" : null,
+ input,
+ output,
+ provided_model_name: null,
+ provided_usage_details: {},
+ usage_details: {},
+ provided_cost_details: {},
+ cost_details: {},
+ metadata_names: ["region", "variant"],
+ metadata_values: [approved ? "eu" : "us", RUN_NAMES[runIndex]],
+ experiment_id: experimentId,
+ experiment_name: RUN_NAMES[runIndex],
+ experiment_dataset_id: datasetId,
+ experiment_item_id: item.id,
+ experiment_item_version: toClickhouseDateTime(validFrom),
+ experiment_item_root_span_id: spanId,
+ experiment_item_expected_output: JSON.stringify(
+ item.expectedOutput,
+ ),
+ experiment_item_metadata_names: ["category", "cohort"],
+ experiment_item_metadata_values: [
+ item.metadata.category,
+ item.metadata.cohort,
+ ],
+ start_time: startTime,
+ end_time: startTime + 300 + runIndex * 100,
+ created_at: startTime,
+ updated_at: startTime,
+ event_ts: startTime,
+ event_bytes: Buffer.byteLength(input) + Buffer.byteLength(output),
+ }),
+ );
+ const scoreBase = {
+ project_id: ctx.projectId,
+ trace_id: traceId,
+ observation_id: spanId,
+ environment: ctx.environment,
+ source: "EVAL" as const,
+ comment: null,
+ metadata: {},
+ timestamp: startTime,
+ created_at: startTime,
+ updated_at: startTime,
+ event_ts: startTime,
+ };
+ if (extraScoreNames > 0) {
+ scores.push(
+ createTraceScore({
+ ...scoreBase,
+ id: `${spanId}-extra`,
+ observation_id: runIndex === 1 ? null : spanId,
+ name: `metric-${String(itemIndex % extraScoreNames).padStart(4, "0")}`,
+ value: (itemIndex % 100) / 100,
+ data_type: "NUMERIC",
+ }),
+ );
+ }
+ if (quality !== null) {
+ scores.push(
+ createTraceScore({
+ ...scoreBase,
+ id: `${spanId}-quality`,
+ name: "quality",
+ value: quality,
+ data_type: "NUMERIC",
+ }),
+ );
+ }
+ scores.push(
+ createTraceScore({
+ ...scoreBase,
+ id: `${spanId}-approved`,
+ name: "approved",
+ value: approved ? 1 : 0,
+ string_value: approved ? "True" : "False",
+ data_type: "BOOLEAN",
+ }),
+ createTraceScore({
+ ...scoreBase,
+ id: `${spanId}-verdict`,
+ name: "verdict",
+ value: verdictIndex,
+ string_value: VERDICTS[verdictIndex],
+ data_type: "CATEGORICAL",
+ }),
+ );
+ }
+ }
+
+ const counts = {
+ datasets: 1,
+ experiments: experimentIds.length,
+ datasetItems: items.length,
+ events: events.length,
+ scores: scores.length,
+ };
+ const traceIds = events.map((event) => event.trace_id);
+ const verified: Record<string, number> = {};
+ if (!ctx.dryRun) {
+ ctx.log(
+ `writing ${counts.experiments} experiments over ${items.length} items`,
+ );
+ await prisma.$transaction(
+ async (tx) => {
+ const dataset = {
+ id: datasetId,
+ projectId: ctx.projectId,
+ name: `seed/experiment-filters/${ctx.idPrefix}`,
+ description: `Synthetic filters: ${itemCount} items, three variants, shifted scores and missing results.`,
+ };
+ await tx.dataset.upsert({
+ where: {
+ id_projectId: { id: datasetId, projectId: ctx.projectId },
+ },
+ create: dataset,
+ update: dataset,
+ });
+ for (const [index, id] of experimentIds.entries()) {
+ const experiment = {
+ id,
+ projectId: ctx.projectId,
+ datasetId,
+ name: RUN_NAMES[index],
+ };
+ await tx.datasetRuns.upsert({
+ where: { id_projectId: { id, projectId: ctx.projectId } },
+ create: experiment,
+ update: experiment,
+ });
+ }
+ for (const batch of chunk(items, 1000)) {
+ await tx.datasetItem.createMany({
+ data: batch,
+ skipDuplicates: true,
+ });
+ }
+ },
+ { timeout: 60_000 },
+ );
+ for (const batch of chunk(events, 10_000)) await createEventsCh(batch);
+ for (const batch of chunk(scores, 10_000)) await createScoresCh(batch);
+ verified.datasets = await prisma.dataset.count({
+ where: { id: datasetId, projectId: ctx.projectId },
+ });
+ verified.experiments = await prisma.datasetRuns.count({
+ where: { id: { in: experimentIds }, projectId: ctx.projectId },
+ });
+ verified.datasetItems = await prisma.datasetItem.count({
+ where: { datasetId, projectId: ctx.projectId, validFrom },
+ });
+ verified.events = await countRows(
+ "events_full",
+ "project_id = {projectId: String} AND experiment_id IN {experimentIds: Array(String)} AND span_id = experiment_item_root_span_id",
+ { projectId: ctx.projectId, experimentIds },
+ "uniqExact(span_id)",
+ );
+ verified.scores = await countRows(
+ "scores",
+ "project_id = {projectId: String} AND startsWith(trace_id, {tracePrefix: String})",
+ { projectId: ctx.projectId, tracePrefix: `${ctx.idPrefix}-run-` },
+ "uniqExact(id)",
+ );
+ for (const [entity, expected] of Object.entries(counts)) {
+ if (verified[entity] !== expected) {
+ throw new SeedError(
+ `Readback mismatch: expected ${expected} ${entity}, found ${verified[entity]}`,
+ );
+ }
+ }
+ for (const [runIndex, experimentId] of experimentIds.entries()) {
+ const expectedQualityMatches = items.filter((_, itemIndex) => {
+ if (runIndex === 2 && itemIndex % 6 === 5) return false;
+ const quality = QUALITY[(itemIndex + runIndex * 2) % QUALITY.length];
+ return quality !== null && quality > 0.8;
+ }).length;
+ const matches = await countRows(
+ "scores",
+ "project_id = {projectId: String} AND startsWith(trace_id, {tracePrefix: String}) AND name = 'quality' AND value > 0.8",
+ { projectId: ctx.projectId, tracePrefix: `${experimentId}-trace-` },
+ "uniqExact(id)",
+ );
+ if (matches !== expectedQualityMatches) {
+ throw new SeedError(
+ `Readback mismatch: expected ${expectedQualityMatches} quality > 0.8 matches in ${RUN_NAMES[runIndex]}, found ${matches}`,
+ );
+ }
+ ctx.log(`${RUN_NAMES[runIndex]}: ${matches} quality > 0.8 matches`);
+ }
+ }
+
+ const comparison = new URLSearchParams({ baseline: experimentIds[0] });
+ comparison.append("c", experimentIds[1]);
+ comparison.append("c", experimentIds[2]);
+ return {
+ scenario: "experiment-filters",
+ target: "clickhouse",
+ params,
+ projectId: ctx.projectId,
+ environment: ctx.environment,
+ traceIds: traceIds.slice(0, 5),
+ sessionIds: [],
+ counts,
+ verified,
+ links: [
+ `${ctx.baseUrl}/project/${ctx.projectId}/experiments/results?${comparison}`,
+ ],
+ dryRun: ctx.dryRun,
+ durationMs: Date.now() - startedAt,
+ };
+ },
+};
diff --git a/packages/shared/scripts/seeder/scenarios/index.ts b/packages/shared/scripts/seeder/scenarios/index.ts
index 000c62fde7..e0789f2c51 100644
--- a/packages/shared/scripts/seeder/scenarios/index.ts
+++ b/packages/shared/scripts/seeder/scenarios/index.ts
@@ -4,6 +4,7 @@ import { annotationQueueScenario } from "./annotation-queue";
import { customModelsScenario } from "./custom-models";
import { deepChainScenario } from "./deep-chain";
import { evaluatorGalleryScenario } from "./evaluator-gallery";
+import { experimentFiltersScenario } from "./experiment-filters";
import { experimentIoScenario } from "./experiment-io";
import { incidentSessionScenario } from "./incident-session";
import { longSessionScenario } from "./long-session";
@@ -29,6 +30,7 @@ export const scenarios: Record<string, ScenarioDefinition> = {
"deep-chain": deepChainScenario,
"evaluator-gallery": evaluatorGalleryScenario,
"experiment-io": experimentIoScenario,
+ "experiment-filters": experimentFiltersScenario,
"long-session": longSessionScenario,
"many-traces": manyTracesScenario,
"outlier-traffic": outlierTrafficScenario,
diff --git a/packages/shared/src/features/filters/filterQueryEncoding.ts b/packages/shared/src/features/filters/filterQueryEncoding.ts
index 8369479d35..dc424ff553 100644
--- a/packages/shared/src/features/filters/filterQueryEncoding.ts
+++ b/packages/shared/src/features/filters/filterQueryEncoding.ts
@@ -98,7 +98,7 @@ export const MAX_URL_FILTER_QUERY_LENGTH = 4000;
/**
* Encodes FilterState to the legacy semicolon-delimited format
- * Format: columnId;type;key;operator;value
+ * Format: columnId;type;key;operator;value[;target]
* Multiple filters separated by commas
* Array values joined with |
*/
@@ -138,7 +138,7 @@ export function encodeFiltersGeneric(filters: FilterState): string {
encodedValue = encodeURIComponent(String(f.value));
}
- return `${f.column};${f.type};${key};${f.operator};${encodedValue}`;
+ return `${f.column};${f.type};${key};${f.operator};${encodedValue}${f.target ? `;${encodeURIComponent(f.target)}` : ""}`;
})
.filter((s): s is string => s !== null),
",",
@@ -148,7 +148,7 @@ export function encodeFiltersGeneric(filters: FilterState): string {
/**
* Decodes the legacy semicolon-delimited format to FilterState
- * Format: column;type;key;operator;value
+ * Format: column;type;key;operator;value[;target]
*/
export function decodeFiltersGeneric(query: string): FilterState {
if (!query.trim()) return [];
@@ -161,7 +161,8 @@ export function decodeFiltersGeneric(query: string): FilterState {
for (const filterString of decoded) {
if (!filterString) continue;
- const [column, type, key, operator, encodedValue] = filterString.split(";");
+ const [column, type, key, operator, encodedValue, target] =
+ filterString.split(";");
if (!column || !type || !operator || encodedValue === undefined) {
continue;
@@ -208,6 +209,7 @@ export function decodeFiltersGeneric(query: string): FilterState {
type,
operator: decodedOperator,
value: parsedValue,
+ ...(target ? { target: decodeURIComponent(target) } : {}),
};
// Add key field for types that need it
diff --git a/packages/shared/src/interfaces/filters.ts b/packages/shared/src/interfaces/filters.ts
index d44f73c75b..24ecb49da7 100644
--- a/packages/shared/src/interfaces/filters.ts
+++ b/packages/shared/src/interfaces/filters.ts
@@ -168,20 +168,27 @@ export const categoryOptionsFilter = z.object({
operator: z.enum(filterOperators.categoryOptions),
value: z.array(z.string()),
});
-export const singleFilter = z.discriminatedUnion("type", [
- timeFilter,
- stringFilter,
- numberFilter,
- stringOptionsFilter,
- categoryOptionsFilter,
- arrayOptionsFilter,
- stringObjectFilter,
- numberObjectFilter,
- booleanObjectFilter,
- booleanFilter,
- nullFilter,
- positionInTraceFilter,
-]);
+export const singleFilter = z
+ .discriminatedUnion("type", [
+ timeFilter,
+ stringFilter,
+ numberFilter,
+ stringOptionsFilter,
+ categoryOptionsFilter,
+ arrayOptionsFilter,
+ stringObjectFilter,
+ numberObjectFilter,
+ booleanObjectFilter,
+ booleanFilter,
+ nullFilter,
+ positionInTraceFilter,
+ ])
+ .and(
+ z.object({
+ /** Optional host-owned target reference, persisted with the condition. */
+ target: z.string().min(1).max(512).optional(),
+ }),
+ );
// Single choke point for parsing arrays of filters. `z.preprocess` runs the
// legacy-empty-substring coercion before validation, so both fresh API/tRPC
diff --git a/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts b/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts
index d9584b829a..335ffe7121 100644
--- a/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts
+++ b/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts
@@ -498,7 +498,7 @@ export const eventsExperimentTraceIds = (
.selectRaw("e.project_id", "e.experiment_id", "e.trace_id")
.limitBy("e.trace_id");
-export const buildScoreRowsCTE = (params: BaseScoresParams): CTEWithSchema => {
+export const buildScoreRowsCTE = (params: ScoresCTEParams): CTEWithSchema => {
const queryParams: Record<string, any> = {
projectId: params.projectId,
dataTypes: AGGREGATABLE_SCORE_TYPES,
@@ -508,10 +508,7 @@ export const buildScoreRowsCTE = (params: BaseScoresParams): CTEWithSchema => {
queryParams.startTimeFrom = params.startTimeFrom;
}
- const isTraceLevel = params.level === "trace";
- const observationFilter = isTraceLevel
- ? "AND observation_id IS NULL"
- : "AND observation_id IS NOT NULL";
+ const observationFilter = scoreLevelCondition(params.level);
const query = `
SELECT
@@ -553,8 +550,7 @@ export const buildScoreRowsCTE = (params: BaseScoresParams): CTEWithSchema => {
* name present at both levels collapses into a single averaged value and a
* numeric comparison stops meaning "at either level".
*
- * Only this CTE understands "any" — the other score fragments branch on
- * `level === "trace"` and would silently treat it as observation-level.
+ * The score-row and aggregated-score CTEs support "any".
*/
type ScoresCTEParams = Omit<BaseScoresParams, "level"> & {
level: BaseScoresParams["level"] | "any";
@@ -569,15 +565,7 @@ export const buildScoresCTE = (params: ScoresCTEParams): CTEWithSchema => {
queryParams.startTimeFrom = params.startTimeFrom;
}
- const observationFilter = (() => {
- if (params.level === "any") {
- return "";
- }
- if (params.level === "trace") {
- return "AND observation_id IS NULL";
- }
- return "AND observation_id IS NOT NULL";
- })();
+ const observationFilter = scoreLevelCondition(params.level);
const query = `
SELECT
@@ -616,3 +604,14 @@ export const buildScoresCTE = (params: ScoresCTEParams): CTEWithSchema => {
],
};
};
+
+function scoreLevelCondition(level: ScoresCTEParams["level"]): string {
+ switch (level) {
+ case "any":
+ return "";
+ case "trace":
+ return "AND observation_id IS NULL";
+ case "observation":
+ return "AND observation_id IS NOT NULL";
+ }
+}
diff --git a/web/src/components/design-system/Button/Button.tsx b/web/src/components/design-system/Button/Button.tsx
index 1e8e19aca6..646af0cbc6 100644
--- a/web/src/components/design-system/Button/Button.tsx
+++ b/web/src/components/design-system/Button/Button.tsx
@@ -1,7 +1,11 @@
import { cva } from "class-variance-authority";
import { ExternalLink, type LucideIcon } from "lucide-react";
import Link from "next/link";
-import { type MouseEventHandler, type Ref } from "react";
+import {
+ type ButtonHTMLAttributes,
+ type MouseEventHandler,
+ type Ref,
+} from "react";
import { Spinner } from "@/src/components/design-system/Spinner/Spinner";
import { cn } from "@/src/utils/tailwind";
@@ -63,7 +67,7 @@ type ButtonProps = {
onClick?: never;
type?: never;
}
- | {
+ | ({
href?: never;
ref?: Ref<HTMLButtonElement>;
disabled?: boolean;
@@ -72,7 +76,11 @@ type ButtonProps = {
loading?: boolean;
onClick?: MouseEventHandler<HTMLButtonElement>;
type?: "button" | "submit";
- }
+ "data-state"?: string;
+ } & Pick<
+ ButtonHTMLAttributes<HTMLButtonElement>,
+ "id" | "aria-controls" | "aria-expanded" | "aria-haspopup"
+ >)
);
export function Button(props: ButtonProps) {
@@ -136,6 +144,11 @@ export function Button(props: ButtonProps) {
onClick={props.loading || props.disabled ? undefined : props.onClick}
aria-busy={props.loading}
aria-label={props.text}
+ id={props.id}
+ aria-controls={props["aria-controls"]}
+ aria-expanded={props["aria-expanded"]}
+ aria-haspopup={props["aria-haspopup"]}
+ data-state={props["data-state"]}
>
<span
className={cn(
diff --git a/web/src/components/ui/popover.tsx b/web/src/components/ui/popover.tsx
index d4f6cf4bfa..528a443083 100644
--- a/web/src/components/ui/popover.tsx
+++ b/web/src/components/ui/popover.tsx
@@ -84,6 +84,8 @@ type PopoverControllerProps = {
contentClassName: string;
disabled: boolean;
modal: boolean;
+ /** Keep nested overlays inside a modal's accessible subtree when needed. */
+ portalContainer?: HTMLElement | null;
onOpenChange?: (isOpen: boolean) => void;
renderContent: (control: { closePopover: () => void }) => React.ReactNode;
};
@@ -94,6 +96,7 @@ const PopoverController = ({
contentClassName,
disabled,
modal,
+ portalContainer,
onOpenChange,
renderContent,
}: PopoverControllerProps) => {
@@ -117,6 +120,7 @@ const PopoverController = ({
<PopoverContent
align={align}
className={contentClassName}
+ portalContainer={portalContainer}
onClick={(event) => event.stopPropagation()}
>
{renderContent({ closePopover: () => setIsOpen(false) })}
diff --git a/web/src/features/experiments/components/filters/AvailableExperimentFilters.tsx b/web/src/features/experiments/components/filters/AvailableExperimentFilters.tsx
new file mode 100644
index 0000000000..25e95e011d
--- /dev/null
+++ b/web/src/features/experiments/components/filters/AvailableExperimentFilters.tsx
@@ -0,0 +1,35 @@
+import { type FilterState } from "@langfuse/shared";
+import { ExperimentFilterAvailableChoice } from "./ExperimentFilterAvailableChoice";
+import { experimentFilterCreationChoices } from "./experimentFilterCreationChoices";
+import { type ExperimentFilterOptions } from "./experimentFilterTypes";
+
+export function AvailableExperimentFilters({
+ options,
+ optionsError,
+ onAdd,
+ portalContainer,
+}: AvailableExperimentFiltersProps) {
+ return (
+ <div
+ className="ph-no-capture flex flex-col gap-1"
+ aria-label="Available filters"
+ >
+ <p className="text-muted-foreground px-2 text-xs">Available filters</p>
+ {experimentFilterCreationChoices(options, optionsError).map((choice) => (
+ <ExperimentFilterAvailableChoice
+ key={choice.column}
+ choice={choice}
+ onAdd={onAdd}
+ portalContainer={portalContainer}
+ />
+ ))}
+ </div>
+ );
+}
+
+type AvailableExperimentFiltersProps = {
+ options: ExperimentFilterOptions | undefined;
+ optionsError: string | null;
+ onAdd: (filter: FilterState[number]) => void;
+ portalContainer: HTMLElement | null;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterAddButton.tsx b/web/src/features/experiments/components/filters/ExperimentFilterAddButton.tsx
new file mode 100644
index 0000000000..bb9963e340
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterAddButton.tsx
@@ -0,0 +1,56 @@
+import { type ComponentProps } from "react";
+import { type FilterState } from "@langfuse/shared";
+import { Plus } from "lucide-react";
+import { Button } from "@/src/components/design-system/Button/Button";
+import { PopoverController } from "@/src/components/ui/popover";
+import { ExperimentFilterCreationPopup } from "./ExperimentFilterCreationPopup";
+import { type ExperimentFilterOptions } from "./experimentFilterTypes";
+
+export function ExperimentFilterAddButton({
+ options,
+ optionsError,
+ onAdd,
+ portalContainer,
+}: ExperimentFilterAddButtonProps) {
+ function renderContent({
+ closePopover,
+ }: Parameters<ComponentProps<typeof PopoverController>["renderContent"]>[0]) {
+ return (
+ <ExperimentFilterCreationPopup
+ options={options}
+ optionsError={optionsError}
+ onAdd={onAdd}
+ onClose={closePopover}
+ />
+ );
+ }
+ return (
+ <PopoverController
+ align="start"
+ contentClassName="ph-no-capture w-72"
+ disabled={false}
+ modal={false}
+ portalContainer={portalContainer}
+ renderContent={renderContent}
+ >
+ {renderTrigger}
+ </PopoverController>
+ );
+}
+
+function renderTrigger({
+ Trigger,
+}: Parameters<ComponentProps<typeof PopoverController>["children"]>[0]) {
+ return (
+ <Trigger asChild>
+ <Button text="Add filter" icon={Plus} variant="secondary" size="sm" />
+ </Trigger>
+ );
+}
+
+type ExperimentFilterAddButtonProps = {
+ options: ExperimentFilterOptions | undefined;
+ optionsError: string | null;
+ onAdd: (filter: FilterState[number]) => void;
+ portalContainer: HTMLElement | null;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterAvailableChoice.tsx b/web/src/features/experiments/components/filters/ExperimentFilterAvailableChoice.tsx
new file mode 100644
index 0000000000..943039e307
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterAvailableChoice.tsx
@@ -0,0 +1,32 @@
+import { type FilterState } from "@langfuse/shared";
+import { ExperimentFilterCreationChoice } from "./ExperimentFilterCreationChoice";
+import { ExperimentFilterMetadataChoice } from "./ExperimentFilterMetadataChoice";
+import { type ExperimentFilterCreationChoice as CreationChoice } from "./experimentFilterCreationChoices";
+
+export function ExperimentFilterAvailableChoice({
+ choice,
+ onAdd,
+ portalContainer,
+}: ExperimentFilterAvailableChoiceProps) {
+ function handleChoose(selected: CreationChoice) {
+ if (selected.filter) onAdd(selected.filter);
+ }
+ if (choice.metadataColumn)
+ return (
+ <ExperimentFilterMetadataChoice
+ column={choice.metadataColumn}
+ choice={choice}
+ onAdd={onAdd}
+ portalContainer={portalContainer}
+ />
+ );
+ return (
+ <ExperimentFilterCreationChoice choice={choice} onChoose={handleChoose} />
+ );
+}
+
+type ExperimentFilterAvailableChoiceProps = {
+ choice: CreationChoice;
+ onAdd: (filter: FilterState[number]) => void;
+ portalContainer: HTMLElement | null;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterBlock.tsx b/web/src/features/experiments/components/filters/ExperimentFilterBlock.tsx
new file mode 100644
index 0000000000..86be9d3dff
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterBlock.tsx
@@ -0,0 +1,255 @@
+import { useId } from "react";
+import { useForm } from "react-hook-form";
+import { filterOperators } from "@langfuse/shared";
+import { X } from "lucide-react";
+import { Input } from "@/src/components/design-system/Input/Input";
+import { SelectInput } from "@/src/components/design-system/SelectInput/SelectInput";
+import { Button } from "@/src/components/design-system/Button/Button";
+import { IconButton } from "@/src/components/design-system/IconButton/IconButton";
+import { ScoreTag } from "@/src/components/score-tag";
+import { cn } from "@/src/utils/tailwind";
+import {
+ completeExperimentFilter,
+ EXPERIMENT_FILTER_KINDS,
+ type ExperimentFilterDraft,
+} from "./experimentFilterEditing";
+import {
+ type ExperimentFilterApply,
+ type ExperimentFilterOptions,
+ type ExperimentFilterTarget,
+} from "./experimentFilterTypes";
+import { ExperimentFilterValueEditor } from "./ExperimentFilterValueEditor";
+
+/** Each keyed mount owns only its unfinished form values. */
+export function ExperimentFilterBlock({
+ initialDraft,
+ index,
+ targets,
+ options,
+ optionsError,
+ onApply,
+ onRemove,
+}: ExperimentFilterBlockProps) {
+ const form = useForm<ExperimentFilterDraft>({ defaultValues: initialDraft });
+ const draft = form.watch();
+ const id = useId();
+ const state = prepareBlockState(draft, targets, options, optionsError);
+ const isDirty = form.formState.isDirty;
+
+ function handleApply(values: ExperimentFilterDraft) {
+ const completed = completeExperimentFilter(values);
+ if (completed && isDirty && state.canApply) onApply(completed, index);
+ }
+ function handleRemove() {
+ onRemove(index);
+ }
+ function handleTargetChange(target: string) {
+ form.setValue("target", target, { shouldDirty: true });
+ }
+ function handleScoreChange(key: string) {
+ form.setValue("key", key, { shouldDirty: true });
+ }
+ function handleOperatorChange(operator: string) {
+ form.setValue("operator", operator, { shouldDirty: true });
+ }
+ function handleValueChange(value: ExperimentFilterDraft["value"]) {
+ form.setValue("value", value, { shouldDirty: true });
+ }
+ const handleSubmit = form.handleSubmit(handleApply);
+
+ return (
+ <form
+ className="ph-no-capture flex min-w-0 flex-col gap-2 rounded-md border p-3"
+ aria-label={`${state.title} filter`}
+ onSubmit={handleSubmit}
+ >
+ <div className="flex items-center justify-between gap-2">
+ <span className="text-xs font-bold">{state.title}</span>
+ <IconButton
+ icon={X}
+ label={`Remove ${state.title} filter`}
+ size="sm"
+ onClick={handleRemove}
+ />
+ </div>
+ <div className={cn("flex flex-col gap-1", state.target?.textClassName)}>
+ <label
+ htmlFor={`${id}-target`}
+ className="text-muted-foreground text-xs"
+ >
+ Experiment
+ </label>
+ <SelectInput
+ id={`${id}-target`}
+ aria-label="Filter experiment"
+ value={draft.target}
+ options={state.targets}
+ onValueChange={handleTargetChange}
+ placeholder="Select experiment"
+ search={{ placeholder: "Search experiments" }}
+ error={!state.target}
+ />
+ </div>
+ {!state.target && (
+ <p role="alert" className="text-destructive text-xs">
+ Select an available experiment to apply this filter.
+ </p>
+ )}
+ {state.isScore && (
+ <>
+ <SelectInput
+ aria-label="Score name"
+ value={draft.key}
+ options={state.scoreNames}
+ onValueChange={handleScoreChange}
+ placeholder="Select score"
+ search={{ placeholder: "Search scores" }}
+ emptyMessage={state.emptyScoresMessage}
+ error={state.invalidType}
+ />
+ {state.levels.length > 0 && (
+ <div className="flex flex-wrap gap-1">
+ {state.levels.map((level) => (
+ <ScoreTag key={level} level={level} />
+ ))}
+ </div>
+ )}
+ </>
+ )}
+ {state.isMetadata && (
+ <Input
+ aria-label="Metadata key"
+ placeholder="Metadata key"
+ {...form.register("key")}
+ />
+ )}
+ <SelectInput
+ aria-label="Filter operator"
+ value={draft.operator}
+ options={filterOperators[draft.type].map((value) => ({
+ value,
+ label: value,
+ }))}
+ onValueChange={handleOperatorChange}
+ placeholder="Select operator"
+ />
+ {!state.isPresence && (
+ <ExperimentFilterValueEditor
+ draft={draft}
+ options={options}
+ onChange={handleValueChange}
+ />
+ )}
+ {state.invalidType && (
+ <p role="alert" className="text-destructive text-xs">
+ This score has a different type. Choose a compatible score.
+ </p>
+ )}
+ {state.isWaiting && (
+ <p role="status" className="text-muted-foreground text-xs">
+ Waiting for score options before applying.
+ </p>
+ )}
+ {isDirty && (
+ <Button
+ text="Apply changes"
+ type="submit"
+ size="sm"
+ disabled={!state.canApply}
+ />
+ )}
+ </form>
+ );
+}
+
+function prepareBlockState(
+ draft: ExperimentFilterDraft,
+ targets: readonly ExperimentFilterTarget[],
+ options: ExperimentFilterOptions | undefined,
+ optionsError: string | null,
+) {
+ const kind = EXPERIMENT_FILTER_KINDS.find(
+ (entry) => entry.column === draft.column,
+ );
+ const target = targets.find((entry) => entry.id === draft.target);
+ const isScore = ["numberObject", "booleanObject", "categoryOptions"].includes(
+ draft.type,
+ );
+ const isMetadata = draft.type === "stringObject";
+ const availableNames = scoreNames(draft, options);
+ const allNames = new Set([
+ ...(options?.scores_avg ?? []),
+ ...Object.keys(options?.score_categories ?? {}),
+ ...(options?.score_booleans ?? []),
+ ]);
+ const invalidType =
+ isScore && allNames.has(draft.key) && !availableNames.includes(draft.key);
+ const availableTargets = targets.map((entry) => ({
+ value: entry.id,
+ label: entry.label,
+ }));
+ if (!target)
+ availableTargets.push({
+ value: draft.target,
+ label: `Unavailable experiment (${draft.target})`,
+ });
+ let emptyScoresMessage = "Loading scores…";
+ if (options) emptyScoresMessage = "No scores of this type";
+ if (optionsError) emptyScoresMessage = "Score options unavailable";
+ return {
+ title: kind?.label ?? draft.column,
+ target,
+ targets: availableTargets,
+ isScore,
+ isMetadata,
+ isPresence: isMetadata && ["is set", "is not set"].includes(draft.operator),
+ scoreNames: [
+ ...new Set([...availableNames, ...(draft.key ? [draft.key] : [])]),
+ ].map((value) => ({ value, label: value })),
+ levels: scoreLevels(draft, options),
+ invalidType,
+ emptyScoresMessage,
+ isWaiting:
+ isScore && options === undefined && !optionsError && Boolean(target),
+ canApply: Boolean(
+ completeExperimentFilter(draft) &&
+ target &&
+ !invalidType &&
+ (!isScore || (options !== undefined && !optionsError)),
+ ),
+ };
+}
+
+function scoreNames(
+ draft: ExperimentFilterDraft,
+ options: ExperimentFilterOptions | undefined,
+): string[] {
+ if (draft.type === "numberObject") return options?.scores_avg ?? [];
+ if (draft.type === "categoryOptions")
+ return Object.keys(options?.score_categories ?? {});
+ if (draft.type === "booleanObject") return options?.score_booleans ?? [];
+ return [];
+}
+
+function scoreLevels(
+ draft: ExperimentFilterDraft,
+ options: ExperimentFilterOptions | undefined,
+) {
+ if (draft.type === "numberObject")
+ return options?.score_name_levels_numeric?.[draft.key] ?? [];
+ if (draft.type === "categoryOptions")
+ return options?.score_name_levels_categorical?.[draft.key] ?? [];
+ if (draft.type === "booleanObject")
+ return options?.score_name_levels_boolean?.[draft.key] ?? [];
+ return [];
+}
+
+type ExperimentFilterBlockProps = {
+ initialDraft: ExperimentFilterDraft;
+ index: number;
+ targets: readonly ExperimentFilterTarget[];
+ options: ExperimentFilterOptions | undefined;
+ optionsError: string | null;
+ onApply: ExperimentFilterApply;
+ onRemove: (index: number) => void;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterChoiceLabel.tsx b/web/src/features/experiments/components/filters/ExperimentFilterChoiceLabel.tsx
new file mode 100644
index 0000000000..80e3a4a471
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterChoiceLabel.tsx
@@ -0,0 +1,25 @@
+import { ScoreTag } from "@/src/components/score-tag";
+import { type ExperimentFilterCreationChoice } from "./experimentFilterCreationChoices";
+
+export function ExperimentFilterChoiceLabel({
+ choice,
+}: ExperimentFilterChoiceLabelProps) {
+ return (
+ <span className="flex min-w-0 flex-col gap-1 text-left">
+ <span className="text-muted-foreground text-xs break-all">
+ {choice.description}
+ </span>
+ {choice.levels.length > 0 && (
+ <span className="flex flex-wrap gap-1">
+ {choice.levels.map((level) => (
+ <ScoreTag key={level} level={level} />
+ ))}
+ </span>
+ )}
+ </span>
+ );
+}
+
+type ExperimentFilterChoiceLabelProps = {
+ choice: ExperimentFilterCreationChoice;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterCreationChoice.tsx b/web/src/features/experiments/components/filters/ExperimentFilterCreationChoice.tsx
new file mode 100644
index 0000000000..f4676f0f32
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterCreationChoice.tsx
@@ -0,0 +1,29 @@
+import { Button } from "@/src/components/design-system/Button/Button";
+import { ExperimentFilterChoiceLabel } from "./ExperimentFilterChoiceLabel";
+import { type ExperimentFilterCreationChoice as CreationChoice } from "./experimentFilterCreationChoices";
+
+export function ExperimentFilterCreationChoice({
+ choice,
+ onChoose,
+}: ExperimentFilterCreationChoiceProps) {
+ function handleClick() {
+ onChoose(choice);
+ }
+ return (
+ <div className="flex flex-col items-start gap-1 rounded-md border p-2">
+ <Button
+ text={choice.label}
+ variant="ghost"
+ size="sm"
+ disabled={choice.isDisabled}
+ onClick={handleClick}
+ />
+ <ExperimentFilterChoiceLabel choice={choice} />
+ </div>
+ );
+}
+
+type ExperimentFilterCreationChoiceProps = {
+ choice: CreationChoice;
+ onChoose: (choice: CreationChoice) => void;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterCreationContent.tsx b/web/src/features/experiments/components/filters/ExperimentFilterCreationContent.tsx
new file mode 100644
index 0000000000..716c18ff0c
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterCreationContent.tsx
@@ -0,0 +1,69 @@
+import { useState } from "react";
+import { type FilterState } from "@langfuse/shared";
+import { ExperimentFilterMetadataForm } from "./ExperimentFilterMetadataForm";
+import { ExperimentFilterCreationChoice } from "./ExperimentFilterCreationChoice";
+import {
+ experimentFilterCreationChoices,
+ type ExperimentFilterCreationChoice as CreationChoice,
+} from "./experimentFilterCreationChoices";
+import {
+ type ExperimentFilterOptions,
+ type MetadataFilterColumn,
+} from "./experimentFilterTypes";
+
+/** Creation buffers unmount with the popover; only complete conditions escape. */
+export function ExperimentFilterCreationContent({
+ options,
+ optionsError,
+ onAdd,
+ onCancel,
+}: ExperimentFilterCreationContentProps) {
+ const [metadataColumn, setMetadataColumn] =
+ useState<MetadataFilterColumn | null>(null);
+
+ function handleChoose(choice: CreationChoice) {
+ if (choice.metadataColumn) setMetadataColumn(choice.metadataColumn);
+ else if (choice.filter) onAdd(choice.filter);
+ }
+
+ function handleCancel() {
+ setMetadataColumn(null);
+ onCancel();
+ }
+
+ function handleAdd(filter: FilterState[number]) {
+ setMetadataColumn(null);
+ onAdd(filter);
+ }
+
+ if (metadataColumn)
+ return (
+ <ExperimentFilterMetadataForm
+ column={metadataColumn}
+ onAdd={handleAdd}
+ onCancel={handleCancel}
+ />
+ );
+
+ return (
+ <div className="ph-no-capture flex flex-col gap-1">
+ <p className="text-muted-foreground px-2 pb-2 text-xs">
+ Add to all experiments
+ </p>
+ {experimentFilterCreationChoices(options, optionsError).map((choice) => (
+ <ExperimentFilterCreationChoice
+ key={choice.column}
+ choice={choice}
+ onChoose={handleChoose}
+ />
+ ))}
+ </div>
+ );
+}
+
+type ExperimentFilterCreationContentProps = {
+ options: ExperimentFilterOptions | undefined;
+ optionsError: string | null;
+ onAdd: (filter: FilterState[number]) => void;
+ onCancel: () => void;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterCreationPopup.tsx b/web/src/features/experiments/components/filters/ExperimentFilterCreationPopup.tsx
new file mode 100644
index 0000000000..7b890b17e5
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterCreationPopup.tsx
@@ -0,0 +1,28 @@
+import { type ComponentProps } from "react";
+import { type FilterState } from "@langfuse/shared";
+import { ExperimentFilterCreationContent } from "./ExperimentFilterCreationContent";
+
+export function ExperimentFilterCreationPopup({
+ options,
+ optionsError,
+ onAdd,
+ onClose,
+}: ExperimentFilterCreationPopupProps) {
+ function handleAdd(filter: FilterState[number]) {
+ onAdd(filter);
+ onClose();
+ }
+ return (
+ <ExperimentFilterCreationContent
+ options={options}
+ optionsError={optionsError}
+ onAdd={handleAdd}
+ onCancel={onClose}
+ />
+ );
+}
+
+type ExperimentFilterCreationPopupProps = Pick<
+ ComponentProps<typeof ExperimentFilterCreationContent>,
+ "options" | "optionsError" | "onAdd"
+> & { onClose: () => void };
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterMetadataChoice.tsx b/web/src/features/experiments/components/filters/ExperimentFilterMetadataChoice.tsx
new file mode 100644
index 0000000000..138c56d8fc
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterMetadataChoice.tsx
@@ -0,0 +1,58 @@
+import { type ComponentProps } from "react";
+import { type FilterState } from "@langfuse/shared";
+import { Button } from "@/src/components/design-system/Button/Button";
+import { PopoverController } from "@/src/components/ui/popover";
+import { ExperimentFilterChoiceLabel } from "./ExperimentFilterChoiceLabel";
+import { ExperimentFilterMetadataPopup } from "./ExperimentFilterMetadataPopup";
+import { type ExperimentFilterCreationChoice } from "./experimentFilterCreationChoices";
+import { type MetadataFilterColumn } from "./experimentFilterTypes";
+
+export function ExperimentFilterMetadataChoice({
+ column,
+ choice,
+ onAdd,
+ portalContainer,
+}: ExperimentFilterMetadataChoiceProps) {
+ function renderTrigger({
+ Trigger,
+ }: Parameters<ComponentProps<typeof PopoverController>["children"]>[0]) {
+ return (
+ <div className="flex flex-col items-start gap-1 rounded-md border p-2">
+ <Trigger asChild>
+ <Button text={choice.label} variant="ghost" size="sm" />
+ </Trigger>
+ <ExperimentFilterChoiceLabel choice={choice} />
+ </div>
+ );
+ }
+ function renderContent({
+ closePopover,
+ }: Parameters<ComponentProps<typeof PopoverController>["renderContent"]>[0]) {
+ return (
+ <ExperimentFilterMetadataPopup
+ column={column}
+ onAdd={onAdd}
+ onClose={closePopover}
+ />
+ );
+ }
+ return (
+ <PopoverController
+ align="start"
+ contentClassName="ph-no-capture w-72"
+ disabled={false}
+ modal={false}
+ portalContainer={portalContainer}
+ renderContent={renderContent}
+ >
+ {renderTrigger}
+ </PopoverController>
+ );
+}
+
+type ExperimentFilterMetadataChoiceProps = {
+ column: MetadataFilterColumn;
+ choice: ExperimentFilterCreationChoice;
+ onAdd: (filter: FilterState[number]) => void;
+ portalContainer: HTMLElement | null;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterMetadataForm.tsx b/web/src/features/experiments/components/filters/ExperimentFilterMetadataForm.tsx
new file mode 100644
index 0000000000..aed68099b3
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterMetadataForm.tsx
@@ -0,0 +1,77 @@
+import { useForm } from "react-hook-form";
+import { type FilterState } from "@langfuse/shared";
+import { Input } from "@/src/components/design-system/Input/Input";
+import { Button } from "@/src/components/design-system/Button/Button";
+import {
+ completeExperimentFilter,
+ newExperimentFilterDraft,
+} from "./experimentFilterEditing";
+import { type MetadataFilterColumn } from "./experimentFilterTypes";
+
+export function ExperimentFilterMetadataForm({
+ column,
+ onAdd,
+ onCancel,
+}: ExperimentFilterMetadataFormProps) {
+ const form = useForm<{ key: string }>({ defaultValues: { key: "" } });
+ const key = form.watch("key");
+ const filter = completeMetadataFilter(column, key);
+
+ function handleAdd(values: { key: string }) {
+ const completed = completeMetadataFilter(column, values.key);
+ if (!completed) return;
+ form.reset({ key: "" });
+ onAdd(completed);
+ }
+
+ function handleCancel() {
+ form.reset({ key: "" });
+ onCancel();
+ }
+
+ const handleSubmit = form.handleSubmit(handleAdd);
+
+ return (
+ <form
+ className="ph-no-capture flex flex-col gap-3"
+ aria-label="Add metadata filter"
+ onSubmit={handleSubmit}
+ >
+ <span className="text-sm font-bold">
+ {column === "itemMetadata" ? "Item metadata" : "Metadata"}
+ </span>
+ <p className="text-muted-foreground text-xs">
+ Key is set · All experiments
+ </p>
+ <Input
+ aria-label="Metadata key"
+ placeholder="Metadata key"
+ {...form.register("key")}
+ autoFocus
+ />
+ <div className="flex justify-end gap-2">
+ <Button
+ text="Cancel"
+ variant="ghost"
+ size="sm"
+ onClick={handleCancel}
+ />
+ <Button text="Add filter" type="submit" size="sm" disabled={!filter} />
+ </div>
+ </form>
+ );
+}
+
+function completeMetadataFilter(column: MetadataFilterColumn, key: string) {
+ return completeExperimentFilter({
+ ...newExperimentFilterDraft(column),
+ operator: "is set",
+ key,
+ });
+}
+
+type ExperimentFilterMetadataFormProps = {
+ column: MetadataFilterColumn;
+ onAdd: (filter: FilterState[number]) => void;
+ onCancel: () => void;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterMetadataPopup.tsx b/web/src/features/experiments/components/filters/ExperimentFilterMetadataPopup.tsx
new file mode 100644
index 0000000000..038b137c21
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterMetadataPopup.tsx
@@ -0,0 +1,27 @@
+import { type FilterState } from "@langfuse/shared";
+import { ExperimentFilterMetadataForm } from "./ExperimentFilterMetadataForm";
+import { type MetadataFilterColumn } from "./experimentFilterTypes";
+
+export function ExperimentFilterMetadataPopup({
+ column,
+ onAdd,
+ onClose,
+}: ExperimentFilterMetadataPopupProps) {
+ function handleAdd(filter: FilterState[number]) {
+ onAdd(filter);
+ onClose();
+ }
+ return (
+ <ExperimentFilterMetadataForm
+ column={column}
+ onAdd={handleAdd}
+ onCancel={onClose}
+ />
+ );
+}
+
+type ExperimentFilterMetadataPopupProps = {
+ column: MetadataFilterColumn;
+ onAdd: (filter: FilterState[number]) => void;
+ onClose: () => void;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterSidebar.tsx b/web/src/features/experiments/components/filters/ExperimentFilterSidebar.tsx
new file mode 100644
index 0000000000..8c975a19ce
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterSidebar.tsx
@@ -0,0 +1,106 @@
+import { type ComponentProps } from "react";
+import { type FilterState } from "@langfuse/shared";
+import { useDataTableControls } from "@/src/components/table/data-table-controls";
+import { usePostHogClientCapture } from "@/src/features/posthog-analytics";
+import { ExperimentFilterSidebarView } from "./ExperimentFilterSidebarView";
+import { editExperimentFilter } from "./experimentFilterEditing";
+
+/** Applied conditions belong to the host; this boundary supplies context and analytics. */
+export function ExperimentFilterSidebar({
+ filters,
+ onChange,
+ onClearAll,
+ targets,
+ options,
+ legacyDefaultTarget,
+ optionsError,
+ onRetryOptions,
+ layout = "panel",
+}: ExperimentFilterSidebarProps) {
+ const { open, setOpen, isMobile } = useDataTableControls();
+ const capture = usePostHogClientCapture();
+
+ function handleApply(filter: FilterState[number], index?: number) {
+ const next =
+ index === undefined
+ ? [...filters, filter]
+ : editExperimentFilter(filters, index, filter);
+ if (JSON.stringify(next) === JSON.stringify(filters)) return;
+ onChange(next);
+ const target = filter.target ?? legacyDefaultTarget;
+ capture("filters:applied", {
+ surface: "sidebar",
+ tableName: "experiment-items",
+ isV4: true,
+ column: filter.column,
+ filterType: filter.type,
+ operator: filter.operator,
+ conditionCount: next.length,
+ columnConditionCount: next.filter(
+ (entry) => entry.column === filter.column,
+ ).length,
+ valueCount: Array.isArray(filter.value) ? filter.value.length : 1,
+ targetKind:
+ target === "all" || target === "baseline" ? target : "experiment",
+ });
+ }
+
+ function handleRemove(index: number) {
+ onChange(editExperimentFilter(filters, index, null));
+ capture("filters:cleared", {
+ surface: "sidebar",
+ tableName: "experiment-items",
+ isV4: true,
+ scope: "facet",
+ column: filters[index].column,
+ clearedCount: 1,
+ });
+ }
+
+ function handleOpenChange(nextOpen: boolean) {
+ setOpen(nextOpen);
+ capture("filters:sidebar_toggled", {
+ tableName: "experiment-items",
+ isV4: true,
+ open: nextOpen,
+ trigger: "header",
+ });
+ }
+
+ function handleActiveOnlyChange(enabled: boolean) {
+ capture("filters:active_only_toggled", {
+ tableName: "experiment-items",
+ isV4: true,
+ enabled,
+ });
+ }
+
+ return (
+ <ExperimentFilterSidebarView
+ filters={filters}
+ onApply={handleApply}
+ onRemove={handleRemove}
+ onClearAll={onClearAll}
+ targets={targets}
+ options={options}
+ legacyDefaultTarget={legacyDefaultTarget}
+ optionsError={optionsError}
+ onRetryOptions={onRetryOptions}
+ layout={layout}
+ isCollapsed={layout === "panel" && !isMobile && !open}
+ onOpenChange={handleOpenChange}
+ onActiveOnlyChange={handleActiveOnlyChange}
+ />
+ );
+}
+
+type ExperimentFilterSidebarProps = Pick<
+ ComponentProps<typeof ExperimentFilterSidebarView>,
+ | "filters"
+ | "onClearAll"
+ | "targets"
+ | "options"
+ | "legacyDefaultTarget"
+ | "optionsError"
+ | "onRetryOptions"
+> & { onChange: (filters: FilterState) => void; layout?: "panel" | "inline" };
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterSidebarView.stories.tsx b/web/src/features/experiments/components/filters/ExperimentFilterSidebarView.stories.tsx
new file mode 100644
index 0000000000..c73883f716
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterSidebarView.stories.tsx
@@ -0,0 +1,93 @@
+import { expect, fn, userEvent, within } from "storybook/test";
+import { type FilterState } from "@langfuse/shared";
+import { type ComponentProps } from "react";
+import preview from "../../../../../.storybook/preview";
+import { ExperimentFilterSidebarView } from "./ExperimentFilterSidebarView";
+
+const targets = [
+ { id: "all", label: "All experiments" },
+ { id: "baseline", label: "Baseline" },
+ { id: "run-a", label: "Run A" },
+ { id: "run-b", label: "Run B" },
+];
+const options = {
+ scores_avg: ["passed", "rating", "quality"],
+ score_categories: { rating: ["good"] },
+ score_booleans: ["passed"],
+ level: ["DEFAULT", "ERROR"],
+};
+const numeric = (
+ target: string,
+): Extract<FilterState[number], { type: "numberObject" }> => ({
+ column: "scores_avg",
+ type: "numberObject",
+ key: "quality",
+ operator: ">",
+ value: 0.8,
+ target,
+});
+
+const defaultArgs: ComponentProps<typeof ExperimentFilterSidebarView> = {
+ filters: [],
+ targets,
+ options,
+ legacyDefaultTarget: "baseline",
+ optionsError: null,
+ layout: "panel",
+ isCollapsed: false,
+ onApply: fn(),
+ onRemove: fn(),
+ onClearAll: fn(),
+ onRetryOptions: fn(),
+ onOpenChange: fn(),
+ onActiveOnlyChange: fn(),
+};
+const meta = preview.meta({
+ component: ExperimentFilterSidebarView,
+ args: defaultArgs,
+});
+
+export const Empty = meta.story({});
+export const RepeatedScores = meta.story({
+ args: { filters: [numeric("run-a"), numeric("run-b")] },
+});
+export const OptionsUnavailable = meta.story({
+ args: {
+ filters: [numeric("run-a")],
+ options: undefined,
+ optionsError: "Could not load score options. Try again.",
+ },
+});
+
+export const RetargetOneOccurrence = meta.story({
+ name: "(Test) Retargets and removes individual repeated conditions",
+ args: { filters: [numeric("run-a"), numeric("run-b")] },
+ play: async ({ canvasElement, args }) => {
+ const canvas = within(canvasElement);
+ const page = within(canvasElement.ownerDocument.body);
+ const [first, second] = canvas.getAllByRole("form", {
+ name: "Numeric score filter",
+ });
+ await userEvent.click(
+ within(first).getByRole("combobox", { name: "Filter experiment" }),
+ );
+ await userEvent.click(
+ await page.findByRole("option", { name: "Baseline" }),
+ );
+ await userEvent.click(
+ await within(first).findByRole("button", { name: "Apply changes" }),
+ );
+ await expect(args.onApply).toHaveBeenCalledTimes(1);
+ await expect(args.onApply).toHaveBeenCalledWith(numeric("baseline"), 0);
+ await expect(
+ within(second).getByRole("combobox", { name: "Filter experiment" }),
+ ).toHaveTextContent("Run B");
+ await userEvent.click(
+ within(second).getByRole("button", {
+ name: "Remove Numeric score filter",
+ }),
+ );
+ await expect(args.onRemove).toHaveBeenCalledTimes(1);
+ await expect(args.onRemove).toHaveBeenCalledWith(1);
+ },
+});
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterSidebarView.tsx b/web/src/features/experiments/components/filters/ExperimentFilterSidebarView.tsx
new file mode 100644
index 0000000000..b73cb3485d
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterSidebarView.tsx
@@ -0,0 +1,191 @@
+import { useId, useState } from "react";
+import { type FilterState } from "@langfuse/shared";
+import { Filter, PanelLeftClose } from "lucide-react";
+import { Button } from "@/src/components/design-system/Button/Button";
+import { IconButton } from "@/src/components/design-system/IconButton/IconButton";
+import { Checkbox } from "@/src/components/design-system/Checkbox/Checkbox";
+import { cn } from "@/src/utils/tailwind";
+import { AvailableExperimentFilters } from "./AvailableExperimentFilters";
+import { ExperimentFilterAddButton } from "./ExperimentFilterAddButton";
+import { ExperimentFilterBlock } from "./ExperimentFilterBlock";
+import { experimentFilterToDraft } from "./experimentFilterEditing";
+import {
+ type ExperimentFilterApply,
+ type ExperimentFilterOptions,
+ type ExperimentFilterTarget,
+} from "./experimentFilterTypes";
+
+export function ExperimentFilterSidebarView({
+ filters,
+ onApply,
+ onRemove,
+ onClearAll,
+ targets,
+ options,
+ legacyDefaultTarget,
+ optionsError,
+ onRetryOptions,
+ layout,
+ isCollapsed,
+ onOpenChange,
+ onActiveOnlyChange,
+}: ExperimentFilterSidebarViewProps) {
+ const [showOnlyActive, setShowOnlyActive] = useState(true);
+ const [portalContainer, setPortalContainer] = useState<HTMLDivElement | null>(
+ null,
+ );
+ const activeOnlyId = useId();
+ const filterBlocks = prepareFilterBlocks(filters);
+
+ function handleOpen() {
+ onOpenChange(true);
+ }
+ function handleCollapse() {
+ onOpenChange(false);
+ }
+ function handleActiveOnlyChange(checked: boolean | "indeterminate") {
+ const enabled = checked === true;
+ setShowOnlyActive(enabled);
+ onActiveOnlyChange(enabled);
+ }
+
+ if (isCollapsed)
+ return (
+ <div className="flex h-full justify-center pt-2">
+ <IconButton
+ icon={Filter}
+ label="Open filters"
+ size="md"
+ onClick={handleOpen}
+ />
+ </div>
+ );
+
+ return (
+ <>
+ <aside
+ aria-label="Experiment filters"
+ className={cn(
+ "flex min-w-0 flex-col",
+ layout === "panel" && "h-full overflow-hidden",
+ )}
+ >
+ {layout === "panel" && (
+ <div className="flex items-center justify-between gap-2 border-b p-3">
+ <span className="text-sm font-bold">
+ Filters{filters.length > 0 && ` (${filters.length})`}
+ </span>
+ <IconButton
+ icon={PanelLeftClose}
+ label="Collapse filters"
+ size="sm"
+ onClick={handleCollapse}
+ />
+ </div>
+ )}
+ <div
+ className={cn(
+ "flex flex-col gap-3 p-3",
+ layout === "panel" && "min-h-0 flex-1 overflow-y-auto",
+ )}
+ >
+ <div className="flex flex-wrap items-center justify-between gap-2">
+ <label
+ htmlFor={activeOnlyId}
+ className="text-muted-foreground flex items-center gap-2 text-xs"
+ >
+ <Checkbox
+ id={activeOnlyId}
+ checked={showOnlyActive}
+ onCheckedChange={handleActiveOnlyChange}
+ />
+ Show only active
+ </label>
+ {filters.length > 0 && (
+ <Button
+ text="Clear all"
+ variant="ghost"
+ size="sm"
+ onClick={onClearAll}
+ />
+ )}
+ </div>
+ {optionsError && (
+ <div role="alert" className="flex flex-col gap-2 text-xs">
+ <p>{optionsError}</p>
+ <Button
+ text="Retry options"
+ variant="secondary"
+ size="sm"
+ onClick={onRetryOptions}
+ />
+ </div>
+ )}
+ {filters.length === 0 && (
+ <p className="text-muted-foreground py-3 text-center text-xs">
+ No active filters.
+ </p>
+ )}
+ {filterBlocks.map(({ filter, index, key }) => (
+ <ExperimentFilterBlock
+ key={`${key}:${filter.target ?? legacyDefaultTarget}`}
+ initialDraft={experimentFilterToDraft(
+ filter,
+ legacyDefaultTarget,
+ )}
+ index={index}
+ targets={targets}
+ options={options}
+ optionsError={optionsError}
+ onApply={onApply}
+ onRemove={onRemove}
+ />
+ ))}
+ {!showOnlyActive && (
+ <AvailableExperimentFilters
+ options={options}
+ optionsError={optionsError}
+ onAdd={onApply}
+ portalContainer={portalContainer}
+ />
+ )}
+ <ExperimentFilterAddButton
+ options={options}
+ optionsError={optionsError}
+ onAdd={onApply}
+ portalContainer={portalContainer}
+ />
+ </div>
+ </aside>
+ {layout === "inline" && (
+ <div data-layer="popover" ref={setPortalContainer} />
+ )}
+ </>
+ );
+}
+
+function prepareFilterBlocks(filters: FilterState) {
+ const occurrences = new Map<string, number>();
+ return filters.map((filter, index) => {
+ const identity = JSON.stringify(filter);
+ const occurrence = occurrences.get(identity) ?? 0;
+ occurrences.set(identity, occurrence + 1);
+ return { filter, index, key: `${identity}:${occurrence}` };
+ });
+}
+
+type ExperimentFilterSidebarViewProps = {
+ filters: FilterState;
+ onApply: ExperimentFilterApply;
+ onRemove: (index: number) => void;
+ onClearAll: () => void;
+ targets: readonly ExperimentFilterTarget[];
+ options: ExperimentFilterOptions | undefined;
+ legacyDefaultTarget: string;
+ optionsError: string | null;
+ onRetryOptions: () => void;
+ layout: "panel" | "inline";
+ isCollapsed: boolean;
+ onOpenChange: (open: boolean) => void;
+ onActiveOnlyChange: (enabled: boolean) => void;
+};
diff --git a/web/src/features/experiments/components/filters/ExperimentFilterValueEditor.tsx b/web/src/features/experiments/components/filters/ExperimentFilterValueEditor.tsx
new file mode 100644
index 0000000000..1f566e555f
--- /dev/null
+++ b/web/src/features/experiments/components/filters/ExperimentFilterValueEditor.tsx
@@ -0,0 +1,67 @@
+import { type ChangeEvent } from "react";
+import { Input } from "@/src/components/design-system/Input/Input";
+import { SelectInput } from "@/src/components/design-system/SelectInput/SelectInput";
+import { MultiSelectInput } from "@/src/components/design-system/MultiSelectInput/MultiSelectInput";
+import { type ExperimentFilterDraft } from "./experimentFilterEditing";
+import { type ExperimentFilterOptions } from "./experimentFilterTypes";
+
+export function ExperimentFilterValueEditor({
+ draft,
+ options,
+ onChange,
+}: ExperimentFilterValueEditorProps) {
+ function handleTextChange(event: ChangeEvent<HTMLInputElement>) {
+ onChange(event.target.value);
+ }
+
+ if (draft.type === "stringOptions" || draft.type === "categoryOptions") {
+ const values = Array.isArray(draft.value) ? draft.value : [];
+ const offered =
+ draft.type === "stringOptions"
+ ? (options?.level ?? ["DEBUG", "DEFAULT", "WARNING", "ERROR"])
+ : (options?.score_categories?.[draft.key] ?? []);
+ return (
+ <MultiSelectInput
+ aria-label="Filter values"
+ value={values}
+ options={[...new Set([...offered, ...values])].map((value) => ({
+ value,
+ label: value,
+ }))}
+ onValueChange={onChange}
+ placeholder="Select values"
+ selectedLabel={values.join(", ")}
+ searchPlaceholder="Search values"
+ emptyMessage={options ? "No values for this score" : "Loading values…"}
+ />
+ );
+ }
+ if (draft.type === "booleanObject" || draft.type === "boolean")
+ return (
+ <SelectInput
+ aria-label="Filter value"
+ value={String(draft.value)}
+ options={[
+ { value: "true", label: "true" },
+ { value: "false", label: "false" },
+ ]}
+ onValueChange={onChange}
+ placeholder="Select value"
+ />
+ );
+ return (
+ <Input
+ aria-label="Filter value"
+ value={String(draft.value)}
+ onChange={handleTextChange}
+ placeholder="Value"
+ inputMode={draft.type === "numberObject" ? "decimal" : "text"}
+ />
+ );
+}
+
+type ExperimentFilterValueEditorProps = {
+ draft: ExperimentFilterDraft;
+ options: ExperimentFilterOptions | undefined;
+ onChange: (value: ExperimentFilterDraft["value"]) => void;
+};
diff --git a/web/src/features/experiments/components/filters/README.md b/web/src/features/experiments/components/filters/README.md
new file mode 100644
index 0000000000..7fcd8c2980
--- /dev/null
+++ b/web/src/features/experiments/components/filters/README.md
@@ -0,0 +1,49 @@
+# Experiment filter sidebar
+
+`ExperimentFilterSidebar` is a controlled editor over the table's canonical URL
+`FilterState`. The host supplies target labels and combined score options for the selected experiments; the
+sidebar owns only visibility and unfinished edit buffers. Each condition is its
+own block, including repeated scores or metadata keys. An Apply action changes
+only that occurrence, and incomplete conditions never reach applied state.
+The container supplies table context and analytics to the prop-only
+`ExperimentFilterSidebarView`. `ExperimentFilterBlock` and
+`ExperimentFilterMetadataForm` own React Hook Form edit buffers; keyed mounts
+reset them when applied conditions change. Interaction stories exercise the
+view with real controls, without query/context mocks.
+
+`ExperimentFilterCreationContent` owns the type picker;
+`AvailableExperimentFilters` owns the inactive catalog. Add filter
+opens a popover: choosing Status applies `DEFAULT`; scores apply the first
+available name with numeric `>= 0`, boolean `true`, or the first categorical
+value. Each choice displays its default before selection. Unavailable score
+types are disabled until options contain a usable score. Metadata collects its
+required key inside the popover and applies `is set`; cancelling discards that
+buffer. New sidebar blocks are always already-applied conditions, never drafts.
+Unchecking Show only active exposes an addable catalog using the same defaults.
+Numeric defaults exclude names also observed as boolean or categorical, even
+when those names appear in the numeric aggregates returned by the host.
+
+`experimentFilterEditing` owns draft conversion, completeness validation and
+condition-level replacement/removal. New conditions explicitly target `all`;
+legacy conditions without a target use the host's `legacyDefaultTarget`
+(baseline, or the first comparison when no baseline is selected). The client expands `all` into the current selection whenever it builds a request,
+so removing or adding an experiment updates its scope. Each request group contains
+ordinary filters and an experiment ID; the backend qualification logic is unchanged.
+
+Apply/remove actions emit existing filtering analytics with counts, field types,
+operators and target kind only. Filter content and experiment identities are not
+included in telemetry; condition editor subtrees are blocked from session replay.
+Creation uses the same apply event exactly once; opening or cancelling its picker
+does not emit a filtering event. Portaled choices and metadata setup retain the
+same replay boundary as the condition editors.
+
+An options request failure displays the host's error and a Retry options action.
+Score changes remain disabled until their options are available; failure is not
+shown as permanent loading. Retry delegates to the host's existing query and
+does not create a new analytics event.
+
+Inline/mobile creation popovers use a feature-owned portal host inside the
+Filters sheet's panel layer. This keeps the popup inside the modal's accessible
+subtree; the global popover layer is hidden by the sheet. Desktop creation keeps
+the default global layer. `PopoverController` forwards the optional container
+without changing its default portal or modal behavior.
diff --git a/web/src/features/experiments/components/filters/experimentFilterCreationChoices.ts b/web/src/features/experiments/components/filters/experimentFilterCreationChoices.ts
new file mode 100644
index 0000000000..f4909446b0
--- /dev/null
+++ b/web/src/features/experiments/components/filters/experimentFilterCreationChoices.ts
@@ -0,0 +1,101 @@
+import { type ExperimentFilterOptions } from "./experimentFilterTypes";
+import {
+ completeExperimentFilter,
+ EXPERIMENT_FILTER_KINDS,
+ newExperimentFilterDraft,
+ type ExperimentFilterDraft,
+} from "./experimentFilterEditing";
+
+export function experimentFilterCreationChoices(
+ options: ExperimentFilterOptions | undefined,
+ optionsError: string | null,
+) {
+ return EXPERIMENT_FILTER_KINDS.map(function prepareChoice(kind) {
+ const draft = prepareDefaultDraft(kind.column, options);
+ const metadataColumn = kind.type === "stringObject" ? kind.column : null;
+ const filter = completeExperimentFilter(draft);
+ return {
+ ...kind,
+ filter,
+ metadataColumn,
+ description: describeDefault(draft, options, optionsError),
+ levels: defaultScoreLevels(draft, options),
+ isDisabled: !metadataColumn && !filter,
+ };
+ });
+}
+
+function prepareDefaultDraft(
+ column: (typeof EXPERIMENT_FILTER_KINDS)[number]["column"],
+ options: ExperimentFilterOptions | undefined,
+): ExperimentFilterDraft {
+ const draft = newExperimentFilterDraft(column);
+ switch (column) {
+ case "level":
+ return { ...draft, value: ["DEFAULT"] };
+ case "scores_avg": {
+ const nonNumericNames = new Set([
+ ...(options?.score_booleans ?? []),
+ ...Object.keys(options?.score_categories ?? {}),
+ ]);
+ const key =
+ options?.scores_avg?.find(
+ (name) => name.length > 0 && !nonNumericNames.has(name),
+ ) ?? "";
+ return { ...draft, key, operator: ">=", value: "0" };
+ }
+ case "score_booleans":
+ return {
+ ...draft,
+ key: options?.score_booleans?.find((name) => name.length > 0) ?? "",
+ value: "true",
+ };
+ case "score_categories": {
+ const category = Object.entries(options?.score_categories ?? {}).find(
+ ([name, values]) => name.length > 0 && values.length > 0,
+ );
+ return {
+ ...draft,
+ key: category?.[0] ?? "",
+ value: category ? [category[1][0]] : [],
+ };
+ }
+ case "itemMetadata":
+ case "eventMetadata":
+ return draft;
+ }
+}
+
+function describeDefault(
+ draft: ExperimentFilterDraft,
+ options: ExperimentFilterOptions | undefined,
+ optionsError: string | null,
+): string {
+ if (draft.type === "stringObject") return "Choose a key · is set";
+ if (draft.column === "level") return "DEFAULT";
+ if (completeExperimentFilter(draft)) {
+ const value = Array.isArray(draft.value)
+ ? JSON.stringify(draft.value[0])
+ : draft.value;
+ return `${draft.key} ${draft.operator} ${value}`;
+ }
+ if (optionsError) return "Score options unavailable";
+ return options ? "No scores of this type" : "Loading scores…";
+}
+
+function defaultScoreLevels(
+ draft: ExperimentFilterDraft,
+ options: ExperimentFilterOptions | undefined,
+) {
+ if (draft.type === "numberObject")
+ return options?.score_name_levels_numeric?.[draft.key] ?? [];
+ if (draft.type === "categoryOptions")
+ return options?.score_name_levels_categorical?.[draft.key] ?? [];
+ if (draft.type === "booleanObject")
+ return options?.score_name_levels_boolean?.[draft.key] ?? [];
+ return [];
+}
+
+export type ExperimentFilterCreationChoice = ReturnType<
+ typeof experimentFilterCreationChoices
+>[number];
diff --git a/web/src/features/experiments/components/filters/experimentFilterEditing.clienttest.ts b/web/src/features/experiments/components/filters/experimentFilterEditing.clienttest.ts
new file mode 100644
index 0000000000..dac99cc401
--- /dev/null
+++ b/web/src/features/experiments/components/filters/experimentFilterEditing.clienttest.ts
@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { type FilterState } from "@langfuse/shared";
+import { editExperimentFilter } from "./experimentFilterEditing";
+
+describe("experiment sidebar condition editing", () => {
+ const filters: FilterState = [
+ {
+ column: "scores_avg",
+ type: "numberObject",
+ key: "quality",
+ operator: ">",
+ value: 0.8,
+ target: "run-a",
+ },
+ {
+ column: "scores_avg",
+ type: "numberObject",
+ key: "quality",
+ operator: "<",
+ value: 0.4,
+ target: "run-b",
+ },
+ {
+ column: "itemMetadata",
+ type: "stringObject",
+ key: "region",
+ operator: "=",
+ value: "eu",
+ target: "all",
+ },
+ {
+ column: "eventMetadata",
+ type: "stringObject",
+ key: "region",
+ operator: "=",
+ value: "us",
+ target: "baseline",
+ },
+ ];
+
+ it("edits and removes one occurrence without replacing its score or metadata siblings", () => {
+ const changed = { ...filters[0], target: "all" };
+ expect(editExperimentFilter(filters, 0, changed)).toEqual([
+ changed,
+ ...filters.slice(1),
+ ]);
+ expect(editExperimentFilter(filters, 2, null)).toEqual([
+ filters[0],
+ filters[1],
+ filters[3],
+ ]);
+ const duplicate = [filters[0], filters[0]];
+ expect(editExperimentFilter(duplicate, 1, null)).toEqual([filters[0]]);
+ });
+});
diff --git a/web/src/features/experiments/components/filters/experimentFilterEditing.ts b/web/src/features/experiments/components/filters/experimentFilterEditing.ts
new file mode 100644
index 0000000000..611f46a5cb
--- /dev/null
+++ b/web/src/features/experiments/components/filters/experimentFilterEditing.ts
@@ -0,0 +1,106 @@
+import { singleFilter, type FilterState } from "@langfuse/shared";
+
+export const EXPERIMENT_FILTER_KINDS = [
+ { column: "level", type: "stringOptions", label: "Status" },
+ { column: "scores_avg", type: "numberObject", label: "Numeric score" },
+ {
+ column: "score_categories",
+ type: "categoryOptions",
+ label: "Categorical score",
+ },
+ { column: "score_booleans", type: "booleanObject", label: "Boolean score" },
+ { column: "itemMetadata", type: "stringObject", label: "Item metadata" },
+ { column: "eventMetadata", type: "stringObject", label: "Metadata" },
+] as const;
+
+export type ExperimentFilterDraft = {
+ column: string;
+ type: FilterState[number]["type"];
+ target: string;
+ operator: string;
+ key: string;
+ value: string | string[];
+};
+
+export function newExperimentFilterDraft(
+ column: string,
+): ExperimentFilterDraft {
+ const kind = EXPERIMENT_FILTER_KINDS.find((entry) => entry.column === column);
+ if (!kind) throw new Error(`Unknown experiment filter column: ${column}`);
+ const optionsType =
+ kind.type === "stringOptions" || kind.type === "categoryOptions";
+ return {
+ column,
+ type: kind.type,
+ target: "all",
+ operator: optionsType ? "any of" : "=",
+ key: "",
+ value: optionsType ? [] : "",
+ };
+}
+
+export function experimentFilterToDraft(
+ filter: FilterState[number],
+ legacyDefaultTarget = "baseline",
+): ExperimentFilterDraft {
+ return {
+ column: filter.column,
+ type: filter.type,
+ target: filter.target ?? legacyDefaultTarget,
+ operator: filter.operator,
+ key: "key" in filter ? filter.key : "",
+ value: Array.isArray(filter.value)
+ ? filter.value
+ : String(filter.value ?? ""),
+ };
+}
+
+/** Incomplete editor values never become an applied condition. */
+export function completeExperimentFilter(
+ draft: ExperimentFilterDraft,
+): FilterState[number] | null {
+ const keyed = [
+ "numberObject",
+ "booleanObject",
+ "categoryOptions",
+ "stringObject",
+ ].includes(draft.type);
+ if (keyed && draft.key.length === 0) return null;
+ const presence =
+ draft.type === "stringObject" &&
+ ["is set", "is not set"].includes(draft.operator);
+ if (
+ !presence &&
+ (Array.isArray(draft.value)
+ ? draft.value.length === 0
+ : draft.value.trim() === "")
+ )
+ return null;
+ let value: unknown = draft.value;
+ if (draft.type === "numberObject" || draft.type === "number") {
+ value = Number(draft.value);
+ if (!Number.isFinite(value)) return null;
+ } else if (draft.type === "booleanObject" || draft.type === "boolean") {
+ if (draft.value !== "true" && draft.value !== "false") return null;
+ value = draft.value === "true";
+ } else if (presence) value = "";
+ const result = singleFilter.safeParse({
+ ...draft,
+ ...(keyed ? { key: draft.key } : {}),
+ value,
+ });
+ return result.success ? result.data : null;
+}
+
+/** Address the occurrence, not the column/key/target: identical predicates may coexist. */
+export function editExperimentFilter(
+ filters: FilterState,
+ index: number,
+ replacement: FilterState[number] | null,
+): FilterState {
+ if (index < 0 || index >= filters.length) return filters;
+ return filters.flatMap((filter, currentIndex) => {
+ if (currentIndex !== index) return [filter];
+ return replacement ? [replacement] : [];
+ });
+}
diff --git a/web/src/features/experiments/components/filters/experimentFilterTypes.ts b/web/src/features/experiments/components/filters/experimentFilterTypes.ts
new file mode 100644
index 0000000000..7e958dbeab
--- /dev/null
+++ b/web/src/features/experiments/components/filters/experimentFilterTypes.ts
@@ -0,0 +1,20 @@
+import { type FilterState } from "@langfuse/shared";
+import { type ExperimentItemScoreFilterOptions } from "../../types/charts";
+
+export type ExperimentFilterTarget = {
+ id: string;
+ label: string;
+ textClassName?: string;
+};
+
+export type ExperimentFilterOptions = ExperimentItemScoreFilterOptions & {
+ itemMetadata?: Record<string, string[]>;
+ eventMetadata?: Record<string, string[]>;
+};
+
+export type ExperimentFilterApply = (
+ filter: FilterState[number],
+ index?: number,
+) => void;
+
+export type MetadataFilterColumn = "itemMetadata" | "eventMetadata";
diff --git a/web/src/features/experiments/components/table/ExperimentFilterPills.tsx b/web/src/features/experiments/components/table/ExperimentFilterPills.tsx
deleted file mode 100644
index 882a0129f4..0000000000
--- a/web/src/features/experiments/components/table/ExperimentFilterPills.tsx
+++ /dev/null
@@ -1,204 +0,0 @@
-/* eslint-disable @repo/no-style-props */
-import { Badge } from "@/src/components/ui/badge";
-import { Button } from "@/src/components/ui/button";
-import {
- Popover,
- PopoverContent,
- PopoverTrigger,
-} from "@/src/components/ui/popover";
-import { ListFilter, X, Check } from "lucide-react";
-import { DropdownIndicator } from "@/src/components/design-system/DropdownIndicator/DropdownIndicator";
-import { useMemo, useState } from "react";
-import { type FilterCondition, type FilterState } from "@langfuse/shared";
-import { cn } from "@/src/utils/tailwind";
-
-interface ExperimentFilterPillsProps {
- filtersByExperiment: { runId: string; filters: FilterState }[];
- selectedExperimentNames: { experimentId: string; experimentName: string }[];
- onFilterTargetChange: (
- fromExperimentId: string,
- toExperimentId: string,
- filter: FilterCondition,
- filterIndex: number,
- ) => void;
- onFilterRemove: (experimentId: string, filterIndex: number) => void;
- className?: string;
-}
-
-function operatorToText(operator: FilterCondition["operator"]): string {
- return String(operator);
-}
-
-function formatFilterForPill(filter: FilterCondition): string {
- const { column, operator, value } = filter;
-
- // Handle object filters with key
- if (
- (filter.type === "numberObject" ||
- filter.type === "stringObject" ||
- filter.type === "booleanObject") &&
- "key" in filter
- ) {
- const valueStr = Array.isArray(value) ? value.join(", ") : String(value);
- return `${filter.key} ${operatorToText(operator)} ${valueStr}`;
- }
-
- // Handle category options with key
- if (filter.type === "categoryOptions" && "key" in filter) {
- const valueStr = Array.isArray(value) ? value.join(", ") : String(value);
- return `${filter.key} ${operatorToText(operator)} ${valueStr}`;
- }
-
- // Handle array values
- if (Array.isArray(value)) {
- const valueStr =
- value.length > 2
- ? `${value.slice(0, 2).join(", ")}...`
- : value.join(", ");
- return `${column} ${operatorToText(operator)} ${valueStr}`;
- }
-
- // Handle simple values
- const valueStr = String(value);
- const displayValue =
- valueStr.length > 20 ? valueStr.slice(0, 20) + "..." : valueStr;
- return `${column} ${operatorToText(operator)} ${displayValue}`;
-}
-
-interface FilterPillWithTargetProps {
- filter: FilterCondition;
- experimentId: string;
- experimentName: string;
- selectedExperimentNames: { experimentId: string; experimentName: string }[];
- onTargetChange: (toExperimentId: string) => void;
- onRemove: () => void;
-}
-
-function FilterPillWithTarget({
- filter,
- experimentId,
- experimentName,
- selectedExperimentNames,
- onTargetChange,
- onRemove,
-}: FilterPillWithTargetProps) {
- const [open, setOpen] = useState(false);
- const filterLabel = formatFilterForPill(filter);
-
- return (
- <Badge
- variant="secondary"
- className="flex max-w-full items-center gap-1 px-2 py-1 text-xs"
- >
- <ListFilter className="icon-sm shrink-0" />
- <span className="truncate" title={filterLabel}>
- {filterLabel}
- </span>
- <span className="text-muted-foreground shrink-0">→</span>
- <Popover open={open} onOpenChange={setOpen}>
- <PopoverTrigger asChild>
- <button
- className="flex shrink-0 items-center gap-0.5 font-bold hover:underline"
- title={experimentName}
- >
- <span className="max-w-[100px] truncate" title={experimentName}>
- {experimentName}
- </span>
- <DropdownIndicator direction="up-down" size="sm" nudge />
- </button>
- </PopoverTrigger>
- <PopoverContent className="w-[200px] p-1" align="start">
- <div className="text-muted-foreground px-2 py-1.5 text-xs font-bold">
- Target Experiment
- </div>
- <div className="space-y-0.5">
- {selectedExperimentNames.map((exp) => (
- <button
- key={exp.experimentId}
- onClick={() => {
- if (exp.experimentId !== experimentId) {
- onTargetChange(exp.experimentId);
- }
- setOpen(false);
- }}
- className={cn(
- "hover:bg-muted flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-sm",
- exp.experimentId === experimentId && "bg-muted",
- )}
- >
- <div className="flex h-4 w-4 items-center justify-center">
- {exp.experimentId === experimentId && (
- <Check className="text-primary icon-sm" />
- )}
- </div>
- <span className="truncate" title={exp.experimentName}>
- {exp.experimentName}
- </span>
- </button>
- ))}
- </div>
- </PopoverContent>
- </Popover>
- <Button
- variant="ghost"
- size="sm"
- className="h-4 w-4 shrink-0 p-0 hover:bg-transparent"
- onClick={(e) => {
- e.stopPropagation();
- onRemove();
- }}
- >
- <X className="icon-base text-icon-foreground" />
- </Button>
- </Badge>
- );
-}
-
-export function ExperimentFilterPills({
- filtersByExperiment,
- selectedExperimentNames,
- onFilterTargetChange,
- onFilterRemove,
- className,
-}: ExperimentFilterPillsProps) {
- // Flatten all filters with their associated experiment information
- const allFilters = useMemo(() => {
- return filtersByExperiment.flatMap((expFilter) =>
- expFilter.filters.map((filter, index) => ({
- filter,
- filterIndex: index,
- experimentId: expFilter.runId,
- experimentName:
- selectedExperimentNames.find(
- (exp) => exp.experimentId === expFilter.runId,
- )?.experimentName ?? expFilter.runId,
- key: `${expFilter.runId}-${index}`,
- })),
- );
- }, [filtersByExperiment, selectedExperimentNames]);
-
- return (
- <div
- className={cn("flex flex-wrap items-center gap-1.5 px-2 py-2", className)}
- >
- {allFilters.map((item) => (
- <FilterPillWithTarget
- key={item.key}
- filter={item.filter}
- experimentId={item.experimentId}
- experimentName={item.experimentName}
- selectedExperimentNames={selectedExperimentNames}
- onTargetChange={(toExperimentId) =>
- onFilterTargetChange(
- item.experimentId,
- toExperimentId,
- item.filter,
- item.filterIndex,
- )
- }
- onRemove={() => onFilterRemove(item.experimentId, item.filterIndex)}
- />
- ))}
- </div>
- );
-}
diff --git a/web/src/features/experiments/components/table/ExperimentGridCell.tsx b/web/src/features/experiments/components/table/ExperimentGridCell.tsx
index 920b066955..6114c949b8 100644
--- a/web/src/features/experiments/components/table/ExperimentGridCell.tsx
+++ b/web/src/features/experiments/components/table/ExperimentGridCell.tsx
@@ -37,7 +37,6 @@ import { cn } from "@/src/utils/tailwind";
import Link from "next/link";
import { type ScoreLevel } from "@/src/components/score-tag";
import { NotRecordedMetric } from "./NotRecordedMetric";
-import { describeRunComparison } from "@/src/features/experiments/fns/describeRunComparison";
type ExperimentGridCellProps = {
projectId: string;
@@ -371,12 +370,6 @@ const CellMetadataFooter = ({
diff={data.latencyDiff}
preferNegativeDiff
formatValue={formatLatency}
- title={describeRunComparison({
- baselineName: data.baselineExperimentName,
- baselineText: formatLatency(data.baselineLatencyMs ?? 0),
- currentText: formatLatency(data.latencyMs ?? 0),
- verb: "took",
- })}
/>
)}
</div>
@@ -401,12 +394,6 @@ const CellMetadataFooter = ({
diff={data.totalCostDiff}
preferNegativeDiff
formatValue={formatCost}
- title={describeRunComparison({
- baselineName: data.baselineExperimentName,
- baselineText: formatCost(data.baselineTotalCost ?? 0),
- currentText: formatCost(data.totalCost ?? 0),
- verb: "cost",
- })}
/>
)}
</div>
diff --git a/web/src/features/experiments/components/table/ExperimentItemsTable.tsx b/web/src/features/experiments/components/table/ExperimentItemsTable.tsx
index 608ac2c842..081ff23015 100644
--- a/web/src/features/experiments/components/table/ExperimentItemsTable.tsx
+++ b/web/src/features/experiments/components/table/ExperimentItemsTable.tsx
@@ -3,10 +3,9 @@
import { useRouter } from "next/router";
import { useExperimentResultsState } from "@/src/features/experiments/hooks/useExperimentResultsState";
import { DataTableToolbar } from "@/src/components/table/data-table-toolbar";
-import {
- DataTableControlsProvider,
- DataTableControls,
-} from "@/src/components/table/data-table-controls";
+import { Button } from "@/src/components/design-system/Button/Button";
+import { DataTableControlsProvider } from "@/src/components/table/data-table-controls";
+import { ExperimentFilterSidebar } from "../filters/ExperimentFilterSidebar";
import { SearchableTableFilterLayout } from "@/src/components/table/resizable-filter-layout";
import { useEffect, useMemo, useState, useRef, useCallback } from "react";
import { RunEvaluationDialog } from "@/src/features/batch-actions";
@@ -27,15 +26,16 @@ import {
import { type LangfuseColumnDef } from "@/src/components/table/types";
import {
type AggregatedScoreData,
- type FilterState,
- type FilterCondition,
TableViewPresetTableName,
BatchExportTableName,
ActionId,
BatchActionType,
EXPERIMENT_IO_TRUNCATE_LENGTH,
} from "@langfuse/shared";
-import { ExperimentFilterPills } from "./ExperimentFilterPills";
+import {
+ getExperimentBatchEvaluationFilters,
+ groupExperimentFilters,
+} from "../../lib/experimentFilterTargets";
import { usePostHogClientCapture } from "@/src/features/posthog-analytics";
import {
COMPARISON_OPERATOR_PROPERTY,
@@ -66,12 +66,7 @@ import { useDetailPageLists } from "@/src/features/navigate-detail-pages";
import { useTableViewManager } from "@/src/components/table/table-view-presets/hooks/useTableViewManager";
import { useTableViewFilterChange } from "@/src/components/table/table-view-presets/hooks/useTableViewFilterChange";
import { TableSearchBar, toObservedOptions } from "@/src/features/search-bar";
-
-import { EXPERIMENT_ITEMS_FIELD_REGISTRY } from "@/src/features/experiments/constants/experimentItemsSearchRegistry";
-import {
- reconcileFilterTargets,
- hasAmbiguousTargetChange,
-} from "@/src/features/experiments/lib/reconcileFilterTargets";
+import { useExperimentItemsSearchRegistry } from "../../hooks/useExperimentItemsSearchRegistry";
import { useExperimentItemsTableData } from "../../hooks/useExperimentItemsTableData";
import { useExpectedOutputVisibility } from "../../hooks/useExpectedOutputVisibility";
import {
@@ -234,11 +229,6 @@ function buildScoreColumnSummaries({
return summaries;
}
-const getDefaultExperimentFilterTarget = (props: {
- baselineId?: string;
- comparisonIds: string[];
-}) => props.baselineId ?? props.comparisonIds[0];
-
const shouldEnableExperimentPeek = (props: {
hasBaseline: boolean;
hideControls: boolean;
@@ -571,10 +561,6 @@ export default function ExperimentItemsTable({
const showComparisonDiff = diffMode !== "off";
const isExpectedDiff = diffMode === "expected";
- const defaultFilterTargetExperimentId = getDefaultExperimentFilterTarget({
- baselineId,
- comparisonIds,
- });
const hasSelectedRuns = allExperimentIds.length > 0;
const canUsePeek = shouldEnableExperimentPeek({
hasBaseline,
@@ -656,153 +642,52 @@ export default function ExperimentItemsTable({
filterOptions: scoreFilterOptions,
scoreColumns: serverScoreColumnDefs,
isLoading: isFilterOptionsLoading,
+ error: filterOptionsError,
+ retry: retryFilterOptions,
} = useExperimentItemsFilterOptions({
projectId,
experimentIds: allExperimentIds,
});
+ const sidebarScoreOptions =
+ isFilterOptionsLoading || filterOptionsError
+ ? undefined
+ : scoreFilterOptions;
+ const searchRegistry = useExperimentItemsSearchRegistry({
+ baselineId,
+ experimentIds: allExperimentIds,
+ selectedExperiments: selectedExperimentNames,
+ colorExperimentIds,
+ optionsError:
+ filterOptionsError ??
+ (isFilterOptionsLoading
+ ? "Score options are still loading. Try again when they have loaded."
+ : null),
+ });
+
// Use sidebar filter state for the sidebar UI (provides proper facets, options, etc.)
// This is the single source of truth for filters
const capture = usePostHogClientCapture();
const { viewControllersRef, onExplicitFilterStateChange } =
useTableViewFilterChange();
- const [filterTargetState, setFilterTargetState] = useState<{
- filters: FilterState;
- targets: Record<number, string>;
- }>({ filters: [], targets: {} });
const queryFilter = useSidebarFilterState(
experimentItemsFilterConfig,
scoreFilterOptions,
{
stateLocation: "url",
- onExplicitFilterStateChange: (change) => {
- setFilterTargetState((state) => ({
- filters: change.nextFilters,
- targets:
- change.origin === "saved_view"
- ? {}
- : reconcileFilterTargets(
- change.previousFilters,
- change.nextFilters,
- reconcileFilterTargets(
- state.filters,
- change.previousFilters,
- state.targets,
- ),
- ),
- }));
- onExplicitFilterStateChange(change);
- },
+ onExplicitFilterStateChange,
loading: isFilterOptionsLoading,
// v4-only surface — drives `isV4` on filters:* analytics.
isV4: true,
},
);
- // The assignment carries its condition so URL navigation cannot attach a
- // previous index's experiment to an unrelated condition.
- const filterTargets = reconcileFilterTargets(
- filterTargetState.filters,
+ const groupedFilters = groupExperimentFilters(
queryFilter.filterState,
- filterTargetState.targets,
- );
-
- // Create ref-based wrapper to avoid stale closure when queryFilter updates
- const queryFilterRef = useRef(queryFilter);
- queryFilterRef.current = queryFilter;
-
- // Build filter list for pills display
- // Group filters by their target experiment (defaults to baseline)
- const filtersByExperiment = useMemo(() => {
- const filterState = queryFilter.filterState;
- if (filterState.length === 0) return [];
- if (!defaultFilterTargetExperimentId) return [];
-
- // Group filters by target experiment
- const grouped: Record<string, FilterState> = {};
- filterState.forEach((filter, index) => {
- const targetExp = filterTargets[index] ?? defaultFilterTargetExperimentId;
- if (!grouped[targetExp]) {
- grouped[targetExp] = [];
- }
- grouped[targetExp].push(filter);
- });
-
- // Convert to array format expected by ExperimentFilterPills
- return Object.entries(grouped).map(([runId, filters]) => ({
- runId,
- filters,
- }));
- }, [queryFilter.filterState, filterTargets, defaultFilterTargetExperimentId]);
-
- // Handler for changing filter target experiment
- const handleFilterTargetChange = useCallback(
- (
- _fromExperimentId: string,
- toExperimentId: string,
- _filter: FilterCondition,
- filterIndex: number,
- ) => {
- // Find the original filter index in queryFilter.filterState
- // We need to map from the grouped index back to the original index
- const filterState = queryFilterRef.current.filterState;
-
- // Count filters up to the current group to find original index
- let originalIndex = -1;
- let currentGroupIndex = 0;
-
- for (let i = 0; i < filterState.length; i++) {
- const target = filterTargets[i] ?? defaultFilterTargetExperimentId;
- if (target === _fromExperimentId) {
- if (currentGroupIndex === filterIndex) {
- originalIndex = i;
- break;
- }
- currentGroupIndex++;
- }
- }
-
- if (originalIndex < 0) return;
- viewControllersRef.current?.handleUserStateChange(
- filterTargets[originalIndex] ?? defaultFilterTargetExperimentId,
- toExperimentId,
- );
- // Update the target for this filter
- setFilterTargetState({
- filters: filterState,
- targets: { ...filterTargets, [originalIndex]: toExperimentId },
- });
- },
- [filterTargets, defaultFilterTargetExperimentId, viewControllersRef],
- );
-
- // Handler for removing a filter via pill
- const handleFilterRemove = useCallback(
- (experimentIdToRemoveFrom: string, filterIndex: number) => {
- const filterState = queryFilterRef.current.filterState;
-
- // Find the original filter index
- let originalIndex = -1;
- let currentGroupIndex = 0;
-
- for (let i = 0; i < filterState.length; i++) {
- const target = filterTargets[i] ?? defaultFilterTargetExperimentId;
- if (target === experimentIdToRemoveFrom) {
- if (currentGroupIndex === filterIndex) {
- originalIndex = i;
- break;
- }
- currentGroupIndex++;
- }
- }
-
- if (originalIndex < 0) return;
- // Remove the filter from queryFilter
- const newFilters = filterState.filter((_, idx) => idx !== originalIndex);
- queryFilterRef.current.setFilterState(newFilters);
- },
- [filterTargets, defaultFilterTargetExperimentId],
+ baselineId,
+ allExperimentIds,
);
+ const filtersByExperiment = groupedFilters.groups;
// A compact row stays on the short preview. Medium, Large, and a dragged
// height at or above this layout's Medium preset ask for the expanded read.
@@ -817,6 +702,7 @@ export default function ExperimentItemsTable({
const { items, totalCount, dataUpdatedAt, ioLoading, isTotalCountLoading } =
useExperimentItemsTableData({
projectId,
+ filtersValid: !groupedFilters.error,
baseExperimentId: baselineId,
compExperimentIds: comparisonIds,
filterByExperiment: filtersByExperiment.map((filter) => ({
@@ -1621,6 +1507,7 @@ export default function ExperimentItemsTable({
const [columnVisibility, setColumnVisibilityState] =
useColumnVisibility<ExperimentItemsTableRow>(
`experimentItemsColumnVisibility-compare-v2-${projectId}`,
+
columns,
);
@@ -1776,21 +1663,6 @@ export default function ExperimentItemsTable({
viewControllers.handleUserStateChange(orderByState, next);
setOrderByState(next);
};
- const searchRegistry = {
- ...EXPERIMENT_ITEMS_FIELD_REGISTRY,
- filterStateErrors: (filters: FilterState) =>
- hasAmbiguousTargetChange(
- queryFilter.searchBarFilterState,
- filters,
- filterTargets,
- defaultFilterTargetExperimentId,
- )
- ? [
- "These edits cannot preserve the filters’ experiment targets. Edit one condition at a time or use its experiment pill.",
- ]
- : [],
- };
-
const peekConfig: DataTablePeekViewProps | undefined = useMemo(() => {
if (!canUsePeek) return undefined;
return {
@@ -1974,11 +1846,24 @@ export default function ExperimentItemsTable({
).length;
}, [selectedRows, rows]);
+ const batchEvaluationFilters = useMemo(
+ () =>
+ getExperimentBatchEvaluationFilters(
+ filtersByExperiment,
+ allExperimentIds,
+ selectAll,
+ ),
+ [filtersByExperiment, allExperimentIds, selectAll],
+ );
+ const isBatchEvaluationDisabled =
+ Boolean(groupedFilters.error) ||
+ (selectAll && batchEvaluationFilters === null);
+
// Build query for batch actions (includes experiment context filter and root span filter)
const batchActionQuery = useMemo(
() => ({
filter: [
- ...filtersByExperiment.flatMap((f) => f.filters),
+ ...(batchEvaluationFilters ?? []),
// Include experiment context filter
...(allExperimentIds.length > 0
? [
@@ -2000,7 +1885,7 @@ export default function ExperimentItemsTable({
],
orderBy: orderByState,
}),
- [filtersByExperiment, orderByState, allExperimentIds],
+ [batchEvaluationFilters, orderByState, allExperimentIds],
);
const handleColumnGroupToggle = useCallback(
@@ -2024,6 +1909,10 @@ export default function ExperimentItemsTable({
type: BatchActionType.Create,
label: "Evaluate",
description: "Run evaluators on selected items",
+ disabled: isBatchEvaluationDisabled,
+ disabledReason: groupedFilters.error
+ ? "Fix unavailable filter targets before evaluating items."
+ : "Select individual rows to evaluate when experiments have different filters.",
icon: <LightbulbIcon className="icon-base sm:mr-2" />,
customDialog: true,
accessCheck: {
@@ -2066,17 +1955,7 @@ export default function ExperimentItemsTable({
viewConfig={{
tableName: TableViewPresetTableName.ExperimentItems,
projectId,
- controllers: {
- ...viewControllers,
- applyViewState: (
- ...args: Parameters<
- typeof viewControllers.applyViewState
- >
- ) => {
- setFilterTargetState({ filters: [], targets: {} });
- viewControllers.applyViewState(...args);
- },
- },
+ controllers: viewControllers,
}}
tableName={experimentItemsFilterConfig.tableName}
isV4={true}
@@ -2123,7 +2002,9 @@ export default function ExperimentItemsTable({
}}
onCustomAction={(actionId) => {
if (
- actionId === ActionId.ObservationBatchEvaluation
+ actionId ===
+ ActionId.ObservationBatchEvaluation &&
+ !isBatchEvaluationDisabled
) {
setShowRunEvaluationDialog(true);
}
@@ -2143,23 +2024,46 @@ export default function ExperimentItemsTable({
/>
)}
- {/* Filter Pills with Experiment Targeting */}
- {filtersByExperiment.length > 0 && (
- <ExperimentFilterPills
- selectedExperimentNames={selectedExperimentNames}
- filtersByExperiment={filtersByExperiment}
- onFilterTargetChange={handleFilterTargetChange}
- onFilterRemove={handleFilterRemove}
- className="border-b"
- />
+ {groupedFilters.error && (
+ <p role="alert" className="text-destructive px-2 py-2 text-sm">
+ {groupedFilters.error}
+ </p>
+ )}
+ {filterOptionsError && (
+ <div
+ role="alert"
+ className="flex items-center gap-2 px-2 py-2 text-sm"
+ >
+ <span className="text-destructive">{filterOptionsError}</span>
+ <Button
+ text="Retry filter options"
+ variant="secondary"
+ size="sm"
+ onClick={retryFilterOptions}
+ />
+ </div>
)}
</>
}
>
{!hideControls && (
- <DataTableControls
- key={viewControllers.filterEditorResetKey}
- queryFilter={queryFilter}
+ <ExperimentFilterSidebar
+ key={`${viewControllers.filterEditorResetKey}:${queryFilter.draftResetKey}`}
+ filters={queryFilter.filterState}
+ onChange={queryFilter.setFilterState}
+ onClearAll={queryFilter.clearAll}
+ targets={(searchRegistry.targeting?.targets ?? []).map(
+ (target) => ({
+ ...target,
+ label: target.displayLabel ?? target.label,
+ }),
+ )}
+ options={sidebarScoreOptions}
+ legacyDefaultTarget={
+ searchRegistry.targeting?.legacyDefaultTarget ?? "baseline"
+ }
+ optionsError={filterOptionsError}
+ onRetryOptions={retryFilterOptions}
/>
)}
@@ -2276,7 +2180,7 @@ export default function ExperimentItemsTable({
)}
{/* Run Evaluation Dialog */}
- {showRunEvaluationDialog && (
+ {showRunEvaluationDialog && !isBatchEvaluationDisabled && (
<RunEvaluationDialog
projectId={projectId}
selectedObservationIds={selectedObservationIds}
diff --git a/web/src/features/experiments/constants/experimentItemsSearchRegistry.clienttest.ts b/web/src/features/experiments/constants/experimentItemsSearchRegistry.clienttest.ts
index d36eb7bc47..59b9f8bd06 100644
--- a/web/src/features/experiments/constants/experimentItemsSearchRegistry.clienttest.ts
+++ b/web/src/features/experiments/constants/experimentItemsSearchRegistry.clienttest.ts
@@ -1,9 +1,17 @@
import { describe, expect, it } from "vitest";
+import {
+ singleFilterList,
+ encodeFiltersGeneric,
+ decodeFiltersGeneric,
+ type FilterState,
+} from "@langfuse/shared";
import { EXPERIMENT_ITEMS_FIELD_REGISTRY } from "./experimentItemsSearchRegistry";
import { planCommit, filterStateToQueryText } from "@/src/features/search-bar";
-
-import { hasAmbiguousTargetChange } from "@/src/features/experiments/lib/reconcileFilterTargets";
-import type { FilterState } from "@langfuse/shared";
+import { experimentItemsFilterTargeting } from "../lib/experimentItemsFilterTargeting";
+import {
+ completeExperimentFilter,
+ experimentFilterToDraft,
+} from "../components/filters/experimentFilterEditing";
describe("experiment item search contract", () => {
it("lowers root/trace score conditions to the same canonical columns as the sidebar", () => {
@@ -48,13 +56,18 @@ describe("experiment item search contract", () => {
value: "test",
},
];
+ const query = filterStateToQueryText(
+ filters,
+ undefined,
+ EXPERIMENT_ITEMS_FIELD_REGISTRY,
+ );
+ expect(query.skippedFilters).toEqual([]);
+ expect(query.text).toBe(
+ "itemMetadata.language:en eventMetadata.model:test",
+ );
expect(
- filterStateToQueryText(
- filters,
- undefined,
- EXPERIMENT_ITEMS_FIELD_REGISTRY,
- ).skippedFilters,
- ).toEqual(filters);
+ planCommit(query.text, undefined, EXPERIMENT_ITEMS_FIELD_REGISTRY),
+ ).toMatchObject({ status: "committed", filters });
expect(
planCommit(
"metadata.language:en",
@@ -70,34 +83,111 @@ describe("experiment item search contract", () => {
).status,
).toBe("invalid");
});
- it("checks target ambiguity over the whole query, allowing unchanged duplicate conditions", () => {
+});
+
+describe("experiment filter targets", () => {
+ const experiments = [
+ { experimentId: "run-a", experimentName: "Run A" },
+ { experimentId: "run-b", experimentName: "Run B" },
+ ];
+ const registryFor = (baselineId: string | undefined, runs = experiments) => ({
+ ...EXPERIMENT_ITEMS_FIELD_REGISTRY,
+ targeting: experimentItemsFilterTargeting({
+ baselineId,
+ experimentIds: ["run-b", "run-a"],
+ experiments: runs,
+ colorExperimentIds: ["run-a", "run-b"],
+ }),
+ });
+
+ it("binds sidebar and typed conditions to the same targets and persists their identities", () => {
+ const registry = registryFor("run-a");
const filters: FilterState = [
{
- column: "level",
- type: "stringOptions",
- operator: "any of",
- value: ["ERROR"],
+ column: "scores_avg",
+ type: "numberObject",
+ key: "quality",
+ operator: ">",
+ value: 0.8,
+ target: "all",
+ },
+ {
+ column: "scores_avg",
+ type: "numberObject",
+ key: "quality",
+ operator: "<",
+ value: 0.6,
+ target: "run-b",
},
{
column: "level",
type: "stringOptions",
operator: "any of",
value: ["ERROR"],
+ target: "baseline",
},
];
- const registry = {
- ...EXPERIMENT_ITEMS_FIELD_REGISTRY,
- filterStateErrors: (next: FilterState) =>
- hasAmbiguousTargetChange(filters, next, { 0: "a", 1: "b" }, "a")
- ? ["Ambiguous target"]
- : [],
- };
expect(
- planCommit("level:ERROR level:ERROR", undefined, registry).status,
- ).toBe("committed");
- expect(planCommit("level:ERROR", undefined, registry).status).toBe(
- "invalid",
+ filters.map((filter) =>
+ completeExperimentFilter(experimentFilterToDraft(filter)),
+ ),
+ ).toEqual(filters);
+ expect(
+ planCommit(
+ 'scores.quality:>0.8 "Run B".scores.quality:<0.6 baseline.level:ERROR',
+ undefined,
+ registry,
+ ),
+ ).toMatchObject({
+ status: "committed",
+ filters,
+ canonical:
+ '"All experiments".scores.quality:>0.8 "Run B".scores.quality:<0.6 baseline.level:ERROR',
+ });
+ expect(
+ planCommit("all.scores.quality:>0.8", undefined, registry),
+ ).toMatchObject({
+ status: "committed",
+ filters: [filters[0]],
+ canonical: '"All experiments".scores.quality:>0.8',
+ });
+ const persisted = singleFilterList.parse(
+ decodeFiltersGeneric(encodeFiltersGeneric(filters)),
+ );
+ expect(persisted).toEqual(filters);
+ const renamed = registryFor(
+ "run-a",
+ experiments.map((run) => ({
+ ...run,
+ experimentName: `${run.experimentName} renamed`,
+ })),
);
- expect(planCommit("", undefined, registry).status).toBe("committed");
+ const query = filterStateToQueryText(persisted, {}, renamed);
+ expect(query.text).toContain('"Run B renamed".scores.quality:<0.6');
+ expect(planCommit(query.text, undefined, renamed)).toMatchObject({
+ filters,
+ });
+ });
+
+ it("keeps targetless saved filters on the baseline or first comparison", () => {
+ const legacy: FilterState = [
+ {
+ type: "numberObject",
+ column: "scores_avg",
+ key: "quality",
+ operator: ">",
+ value: 0.8,
+ },
+ ];
+ const persisted = decodeFiltersGeneric(encodeFiltersGeneric(legacy));
+ expect(persisted).toEqual(legacy);
+ for (const baselineId of ["run-a", undefined]) {
+ const registry = registryFor(baselineId);
+ const query = filterStateToQueryText(persisted, {}, registry);
+ expect(planCommit(query.text, undefined, registry)).toMatchObject({
+ status: "committed",
+ filters: [{ ...legacy[0], target: baselineId ? "baseline" : "run-b" }],
+ });
+ }
});
});
diff --git a/web/src/features/experiments/constants/experimentItemsSearchRegistry.ts b/web/src/features/experiments/constants/experimentItemsSearchRegistry.ts
index ec519c47ae..e5f4375911 100644
--- a/web/src/features/experiments/constants/experimentItemsSearchRegistry.ts
+++ b/web/src/features/experiments/constants/experimentItemsSearchRegistry.ts
@@ -12,9 +12,11 @@ export const EXPERIMENT_ITEMS_FIELD_REGISTRY = fieldRegistryFromColumns(
{
id: "experimentItems",
allowFreeText: false,
- // Item and event metadata use different backend columns; the sidebar owns
- // those namespaces until the grammar can map each namespace independently.
metadata: false,
+ metadataNamespaces: {
+ itemMetadata: "itemMetadata",
+ eventMetadata: "eventMetadata",
+ },
scores: true,
traceScores: false,
recentSearches: true,
diff --git a/web/src/features/experiments/hooks/useExperimentItemsFilterOptions.ts b/web/src/features/experiments/hooks/useExperimentItemsFilterOptions.ts
index 652d3f2156..ddfc174581 100644
--- a/web/src/features/experiments/hooks/useExperimentItemsFilterOptions.ts
+++ b/web/src/features/experiments/hooks/useExperimentItemsFilterOptions.ts
@@ -1,31 +1,10 @@
-import { api } from "@/src/utils/api";
+import { api, type RouterOutputs } from "@/src/utils/api";
import { useMemo } from "react";
import { type ExperimentItemScoreFilterOptions } from "@/src/features/experiments/types/charts";
-export type ScoreColumnDef = {
- name: string;
- dataType: "NUMERIC" | "BOOLEAN" | "CATEGORICAL";
- source: string;
-};
-
const EXPERIMENT_ITEM_LEVEL_OPTIONS = ["DEBUG", "DEFAULT", "WARNING", "ERROR"];
-const processCategoricalScoreOptions = (
- categories: Array<{ label: string; values: string[] }>,
-): Record<string, string[]> =>
- categories.reduce(
- (acc, score) => {
- acc[score.label] = score.values;
- return acc;
- },
- {} as Record<string, string[]>,
- );
-
-/**
- * Experiment item filter options (scores) scoped to specific experiment IDs.
- * Returns the level-agnostic score filter options the three facets offer, plus
- * the per-level score column definitions the table's column visibility uses.
- */
+/** Fetch the combined score options for the selected experiments. */
export const useExperimentItemsFilterOptions = ({
projectId,
experimentIds,
@@ -36,8 +15,6 @@ export const useExperimentItemsFilterOptions = ({
const filterOptions = api.experiments.itemsFilterOptions.useQuery(
{ projectId, experimentIds },
{
- // `projectId` arrives with `router.query` after hydration; without it in
- // the guard the query can fire with `undefined` and zod rejects it.
enabled: Boolean(projectId) && experimentIds.length > 0,
staleTime: Infinity,
refetchOnMount: false,
@@ -45,51 +22,56 @@ export const useExperimentItemsFilterOptions = ({
},
);
- // Transform categorical scores into key-value format for sidebar filters
- const transformedOptions = useMemo(() => {
- if (!filterOptions.data) {
- return {
- scores_avg: undefined,
- score_categories: undefined,
- score_booleans: undefined,
- score_name_levels_numeric: undefined,
- score_name_levels_categorical: undefined,
- score_name_levels_boolean: undefined,
- level: EXPERIMENT_ITEM_LEVEL_OPTIONS,
- } satisfies ExperimentItemScoreFilterOptions;
- }
-
- // One entry per score name across both levels; the level maps tag each
- // offered name with where it exists. `useSidebarFilterState` looks the maps
- // up by these exact keys.
- return {
- scores_avg: filterOptions.data.scores_avg,
- score_categories: processCategoricalScoreOptions(
- filterOptions.data.score_categories,
- ),
- score_booleans: filterOptions.data.score_booleans,
- score_name_levels_numeric: filterOptions.data.score_name_levels_numeric,
- score_name_levels_categorical:
- filterOptions.data.score_name_levels_categorical,
- score_name_levels_boolean: filterOptions.data.score_name_levels_boolean,
- level: EXPERIMENT_ITEM_LEVEL_OPTIONS,
- } satisfies ExperimentItemScoreFilterOptions;
- }, [filterOptions.data]);
+ const transformedOptions = useMemo(
+ () => toFilterOptions(filterOptions.data),
+ [filterOptions.data],
+ );
- // Extract score column definitions for table columns
const scoreColumns = useMemo(
() => ({
- observationScoreColumns: (filterOptions.data?.obs_score_columns ??
- []) as ScoreColumnDef[],
- traceScoreColumns: (filterOptions.data?.trace_score_columns ??
- []) as ScoreColumnDef[],
+ observationScoreColumns: filterOptions.data?.obs_score_columns ?? [],
+ traceScoreColumns: filterOptions.data?.trace_score_columns ?? [],
}),
[filterOptions.data],
);
+ function retry() {
+ return filterOptions.refetch();
+ }
+
return {
filterOptions: transformedOptions,
scoreColumns,
isLoading: filterOptions.isLoading,
+ error: filterOptions.isError
+ ? "Score filter options could not be loaded. Retry to edit score filters."
+ : null,
+ retry,
+ };
+};
+
+function toFilterOptions(
+ data: ItemFilterOptions | undefined,
+): ExperimentItemScoreFilterOptions {
+ return {
+ scores_avg: data?.scores_avg,
+ score_categories: data
+ ? Object.fromEntries(
+ data.score_categories.map(({ label, values }) => [label, values]),
+ )
+ : undefined,
+ score_booleans: data?.score_booleans,
+ score_name_levels_numeric: data?.score_name_levels_numeric,
+ score_name_levels_categorical: data?.score_name_levels_categorical,
+ score_name_levels_boolean: data?.score_name_levels_boolean,
+ level: EXPERIMENT_ITEM_LEVEL_OPTIONS,
};
+}
+
+type ItemFilterOptions = RouterOutputs["experiments"]["itemsFilterOptions"];
+
+export type ScoreColumnDef = {
+ name: string;
+ dataType: "NUMERIC" | "BOOLEAN" | "CATEGORICAL";
+ source: string;
};
diff --git a/web/src/features/experiments/hooks/useExperimentItemsSearchRegistry.ts b/web/src/features/experiments/hooks/useExperimentItemsSearchRegistry.ts
new file mode 100644
index 0000000000..7fac2df90e
--- /dev/null
+++ b/web/src/features/experiments/hooks/useExperimentItemsSearchRegistry.ts
@@ -0,0 +1,42 @@
+import { useMemo } from "react";
+import { EXPERIMENT_ITEMS_FIELD_REGISTRY } from "@/src/features/experiments/constants/experimentItemsSearchRegistry";
+import { experimentItemsFilterTargeting } from "@/src/features/experiments/lib/experimentItemsFilterTargeting";
+import type { FieldRegistry } from "@/src/features/search-bar/lib/fields";
+
+export function useExperimentItemsSearchRegistry({
+ baselineId,
+ experimentIds,
+ selectedExperiments,
+ colorExperimentIds,
+ optionsError,
+}: {
+ baselineId?: string;
+ experimentIds: readonly string[];
+ selectedExperiments: readonly {
+ experimentId: string;
+ experimentName: string;
+ datasetName?: string | null;
+ }[];
+ colorExperimentIds: string[];
+ optionsError: string | null;
+}): FieldRegistry {
+ return useMemo(
+ () => ({
+ ...EXPERIMENT_ITEMS_FIELD_REGISTRY,
+ targeting: experimentItemsFilterTargeting({
+ baselineId,
+ experimentIds,
+ experiments: selectedExperiments,
+ colorExperimentIds,
+ scoreTypesError: optionsError ?? undefined,
+ }),
+ }),
+ [
+ baselineId,
+ experimentIds,
+ selectedExperiments,
+ colorExperimentIds,
+ optionsError,
+ ],
+ );
+}
diff --git a/web/src/features/experiments/hooks/useExperimentItemsTableData.ts b/web/src/features/experiments/hooks/useExperimentItemsTableData.ts
index 4f7adf4c17..a7e316dd8b 100644
--- a/web/src/features/experiments/hooks/useExperimentItemsTableData.ts
+++ b/web/src/features/experiments/hooks/useExperimentItemsTableData.ts
@@ -8,6 +8,7 @@ import {
type UseExperimentItemsTableDataParams = {
projectId: string;
+ filtersValid?: boolean;
baseExperimentId?: string;
compExperimentIds: string[];
filterByExperiment: {
@@ -36,6 +37,7 @@ type UseExperimentItemsTableDataParams = {
*/
export function useExperimentItemsTableData({
projectId,
+ filtersValid = true,
baseExperimentId,
compExperimentIds,
filterByExperiment,
@@ -45,7 +47,7 @@ export function useExperimentItemsTableData({
ioCharLimit,
}: UseExperimentItemsTableDataParams) {
const hasSelectedRuns =
- Boolean(baseExperimentId) || compExperimentIds.length > 0;
+ filtersValid && (Boolean(baseExperimentId) || compExperimentIds.length > 0);
// Prepare query payloads
const getCountPayload = useMemo(
@@ -206,7 +208,10 @@ export function useExperimentItemsTableData({
// already false while its empty data would read as the answer. The payload
// check keeps the flag false when there is genuinely nothing to fetch.
const ioLoading =
- batchIOPayload !== null && !batchIOQuery.isSuccess && !batchIOQuery.isError;
+ hasSelectedRuns &&
+ batchIOPayload !== null &&
+ !batchIOQuery.isSuccess &&
+ !batchIOQuery.isError;
const isTotalCountLoading =
hasSelectedRuns && !totalCountQuery.isSuccess && !totalCountQuery.isError;
diff --git a/web/src/features/experiments/lib/experimentFilterTargets.clienttest.ts b/web/src/features/experiments/lib/experimentFilterTargets.clienttest.ts
new file mode 100644
index 0000000000..9fe72e4465
--- /dev/null
+++ b/web/src/features/experiments/lib/experimentFilterTargets.clienttest.ts
@@ -0,0 +1,106 @@
+import type { FilterState } from "@langfuse/shared";
+import {
+ getExperimentBatchEvaluationFilters,
+ groupExperimentFilters,
+} from "./experimentFilterTargets";
+
+const quality = {
+ column: "scores_avg",
+ type: "numberObject",
+ key: "quality",
+ operator: ">",
+ value: 0.8,
+} satisfies FilterState[number];
+
+describe("experiment filter request groups", () => {
+ it("applies All to every selected experiment alongside its own conditions", () => {
+ const status = {
+ column: "level",
+ type: "stringOptions",
+ operator: "any of",
+ value: ["ERROR"],
+ } satisfies FilterState[number];
+ expect(
+ groupExperimentFilters(
+ [
+ { ...quality, target: "all" },
+ { ...status, target: "b" },
+ ],
+ "a",
+ ["a", "b", "c"],
+ ),
+ ).toEqual({
+ groups: [
+ { runId: "a", filters: [quality] },
+ { runId: "b", filters: [quality, status] },
+ { runId: "c", filters: [quality] },
+ ],
+ });
+ });
+
+ it("keeps explicit targets fixed and legacy filters on baseline or first comparison", () => {
+ expect(groupExperimentFilters([quality], "b", ["a", "b"]).groups).toEqual([
+ { runId: "b", filters: [quality] },
+ ]);
+ expect(
+ groupExperimentFilters([{ ...quality, target: "a" }], "b", ["a", "b"])
+ .groups,
+ ).toEqual([{ runId: "a", filters: [quality] }]);
+ expect(groupExperimentFilters([quality], undefined, ["b", "a"])).toEqual({
+ groups: [{ runId: "b", filters: [quality] }],
+ });
+ });
+
+ it("expands All against the current selection as runs are added and removed", () => {
+ const filters = [{ ...quality, target: "all" }];
+ expect(groupExperimentFilters(filters, undefined, ["a"]).groups).toEqual([
+ { runId: "a", filters: [quality] },
+ ]);
+ expect(
+ groupExperimentFilters(filters, undefined, ["a", "b"]).groups,
+ ).toEqual([
+ { runId: "a", filters: [quality] },
+ { runId: "b", filters: [quality] },
+ ]);
+ expect(groupExperimentFilters(filters, undefined, ["b"]).groups).toEqual([
+ { runId: "b", filters: [quality] },
+ ]);
+ });
+
+ it("blocks unavailable targets without sending a partial filter set", () => {
+ expect(
+ groupExperimentFilters(
+ [
+ { ...quality, target: "all" },
+ { ...quality, target: "missing" },
+ ],
+ "a",
+ ["a"],
+ ),
+ ).toMatchObject({ groups: [], error: expect.any(String) });
+ expect(
+ groupExperimentFilters([{ ...quality, target: "baseline" }], undefined, [
+ "a",
+ ]).error,
+ ).toBeDefined();
+ });
+});
+
+describe("experiment batch evaluation filters", () => {
+ it("blocks select-all for differing conditions but allows explicit rows or a common filter", () => {
+ const groups = [{ runId: "a", filters: [quality] }];
+ expect(
+ getExperimentBatchEvaluationFilters(groups, ["a", "b"], true),
+ ).toBeNull();
+ expect(
+ getExperimentBatchEvaluationFilters(groups, ["a", "b"], false),
+ ).toEqual([]);
+ expect(
+ getExperimentBatchEvaluationFilters(
+ [...groups, { runId: "b", filters: [{ ...quality }] }],
+ ["a", "b"],
+ true,
+ ),
+ ).toEqual([quality]);
+ });
+});
diff --git a/web/src/features/experiments/lib/experimentFilterTargets.ts b/web/src/features/experiments/lib/experimentFilterTargets.ts
new file mode 100644
index 0000000000..72b1a313ff
--- /dev/null
+++ b/web/src/features/experiments/lib/experimentFilterTargets.ts
@@ -0,0 +1,54 @@
+import type { FilterState } from "@langfuse/shared";
+import isEqual from "lodash/isEqual";
+
+/** Resolve symbolic targets only when building the experiment request. */
+export function groupExperimentFilters(
+ filters: FilterState,
+ baselineId: string | undefined,
+ experimentIds: readonly string[],
+): { groups: { runId: string; filters: FilterState }[]; error?: string } {
+ const groups = new Map<string, FilterState>();
+ for (const filter of filters) {
+ let targetId: string | undefined =
+ filter.target ?? baselineId ?? experimentIds[0];
+ if (filter.target === "baseline") targetId = baselineId;
+ const ids = filter.target === "all" ? experimentIds : [targetId];
+ if (ids.some((id) => !id || !experimentIds.includes(id))) {
+ return {
+ groups: [],
+ error:
+ "A filter targets an unavailable experiment. Select a baseline, restore the experiment, or edit the filter target.",
+ };
+ }
+ const { target: _target, ...condition } = filter;
+ for (const id of ids) {
+ if (!id) continue;
+ const group = groups.get(id) ?? [];
+ group.push(condition);
+ groups.set(id, group);
+ }
+ }
+ return {
+ groups: Array.from(groups, ([runId, filters]) => ({ runId, filters })),
+ };
+}
+
+export function getExperimentBatchEvaluationFilters(
+ groups: { runId: string; filters: FilterState }[],
+ experimentIds: readonly string[],
+ selectAll: boolean,
+): FilterState | null {
+ // Explicit selections are constrained by their observation IDs in the dialog.
+ if (!selectAll) return [];
+
+ // Batch evaluation accepts one conjunction, not experiment-qualified groups.
+ const filtersByRun = new Map(
+ groups.map((group) => [group.runId, group.filters]),
+ );
+ const commonFilters = filtersByRun.get(experimentIds[0] ?? "") ?? [];
+ return experimentIds.every((id) =>
+ isEqual(filtersByRun.get(id) ?? [], commonFilters),
+ )
+ ? commonFilters
+ : null;
+}
diff --git a/web/src/features/experiments/lib/experimentItemsFilterTargeting.ts b/web/src/features/experiments/lib/experimentItemsFilterTargeting.ts
new file mode 100644
index 0000000000..6a5207857b
--- /dev/null
+++ b/web/src/features/experiments/lib/experimentItemsFilterTargeting.ts
@@ -0,0 +1,91 @@
+import {
+ type FieldRef,
+ type FilterTargeting,
+} from "@/src/features/search-bar/lib/fields";
+import { getExperimentColorStyles } from "@/src/features/experiments/components/table/types";
+
+export function experimentItemsFilterTargeting({
+ baselineId,
+ experimentIds,
+ experiments,
+ colorExperimentIds,
+ scoreTypesError,
+}: {
+ baselineId?: string;
+ experimentIds: readonly string[];
+ experiments: readonly {
+ experimentId: string;
+ experimentName: string;
+ datasetName?: string | null;
+ }[];
+ colorExperimentIds: string[];
+ scoreTypesError?: string;
+}): FilterTargeting {
+ const experimentsById = new Map(
+ experiments.map((experiment) => [experiment.experimentId, experiment]),
+ );
+ const selectedExperiments = experimentIds.map(
+ (experimentId) =>
+ experimentsById.get(experimentId) ?? {
+ experimentId,
+ experimentName: experimentId,
+ datasetName: null,
+ },
+ );
+ const names = selectedExperiments.map(
+ (experiment) => experiment.experimentName,
+ );
+ const labels = selectedExperiments.map((experiment) =>
+ names.filter((name) => name === experiment.experimentName).length > 1 ||
+ experiment.experimentName === "All experiments"
+ ? `${experiment.experimentName} (${experiment.datasetName ?? "Dataset"})`
+ : experiment.experimentName,
+ );
+ return {
+ defaultTarget: "all",
+ scoreTypesError,
+ legacyDefaultTarget: baselineId ? "baseline" : experimentIds[0],
+ targets: [
+ {
+ id: "all",
+ label: "All experiments",
+ displayLabel: "All experiments",
+ keyword: true,
+ },
+ ...(baselineId
+ ? [
+ {
+ id: "baseline",
+ label: "baseline",
+ displayLabel: "Baseline",
+ keyword: true,
+ textClassName: getExperimentColorStyles(
+ baselineId,
+ colorExperimentIds,
+ ).textClass,
+ },
+ ]
+ : []),
+ ...selectedExperiments.map((experiment, index) => ({
+ id: experiment.experimentId,
+ label:
+ labels.filter((label) => label === labels[index]).length > 1
+ ? `${labels[index]} [${experiment.experimentId}]`
+ : labels[index],
+ textClassName: getExperimentColorStyles(
+ experiment.experimentId,
+ colorExperimentIds,
+ ).textClass,
+ })),
+ ],
+ supports: supportsExperimentItemFilterTarget,
+ };
+}
+
+function supportsExperimentItemFilterTarget(field: FieldRef): boolean {
+ return (
+ field.type === "scores" ||
+ field.type === "metadata" ||
+ (field.type === "field" && field.field.id === "level")
+ );
+}
diff --git a/web/src/features/experiments/lib/reconcileFilterTargets.clienttest.ts b/web/src/features/experiments/lib/reconcileFilterTargets.clienttest.ts
deleted file mode 100644
index ba8dfb618c..0000000000
--- a/web/src/features/experiments/lib/reconcileFilterTargets.clienttest.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { FilterState } from "@langfuse/shared";
-import {
- reconcileFilterTargets,
- hasAmbiguousTargetChange,
-} from "./reconcileFilterTargets";
-
-const previous: FilterState = [
- {
- type: "stringOptions",
- column: "level",
- operator: "any of",
- value: ["ERROR"],
- },
- {
- type: "numberObject",
- column: "scores_avg",
- key: "quality",
- operator: ">",
- value: 0.5,
- },
- {
- type: "numberObject",
- column: "scores_avg",
- key: "safety",
- operator: "<",
- value: 0.8,
- },
-];
-
-describe("experiment filter targets", () => {
- const scoreRange: FilterState = [
- {
- type: "numberObject",
- column: "scores_avg",
- key: "quality",
- operator: ">",
- value: 0.5,
- },
- {
- type: "numberObject",
- column: "scores_avg",
- key: "quality",
- operator: "<",
- value: 0.8,
- },
- ];
- const editedScoreRange: FilterState = [
- {
- type: "numberObject",
- column: "scores_avg",
- key: "quality",
- operator: ">",
- value: 0.6,
- },
- {
- type: "numberObject",
- column: "scores_avg",
- key: "quality",
- operator: "<",
- value: 0.9,
- },
- ];
-
- it("rejects ambiguous edits of the same score across different runs", () => {
- expect(
- hasAmbiguousTargetChange(
- scoreRange,
- editedScoreRange,
- {
- 0: "comparison-a",
- 1: "comparison-b",
- },
- "baseline",
- ),
- ).toBe(true);
- });
-
- it("preserves a common run when multiple conditions change together", () => {
- const targets = { 0: "comparison-a", 1: "comparison-a" };
- expect(
- hasAmbiguousTargetChange(
- scoreRange,
- editedScoreRange,
- targets,
- "baseline",
- ),
- ).toBe(false);
- expect(
- reconcileFilterTargets(scoreRange, editedScoreRange, targets),
- ).toEqual(targets);
- });
-
- it("keeps a run's condition on that run when the bar reorders and removes other filters", () => {
- const next = [structuredClone(previous[2]!), structuredClone(previous[0]!)];
- expect(
- reconcileFilterTargets(previous, next, {
- 0: "baseline",
- 1: "comparison-a",
- 2: "comparison-b",
- }),
- ).toEqual({
- 0: "comparison-b",
- 1: "baseline",
- });
- });
- it("preserves the target of a uniquely edited score and defaults newly added fields", () => {
- const next: FilterState = [
- { ...previous[1]!, value: 0.9 } as FilterState[number],
- {
- type: "booleanObject",
- column: "score_booleans",
- key: "approved",
- operator: "=",
- value: true,
- },
- ];
- expect(
- reconcileFilterTargets(previous, next, {
- 1: "comparison-a",
- 2: "comparison-b",
- }),
- ).toEqual({ 0: "comparison-a" });
- });
- it("uses retained object identity when a targeted pill removes one of two identical conditions", () => {
- const first = structuredClone(previous[0]!);
- const second = structuredClone(previous[0]!);
- expect(
- reconcileFilterTargets([first, second], [second], { 0: "a", 1: "b" }),
- ).toEqual({ 0: "b" });
- expect(
- hasAmbiguousTargetChange(
- [first, second],
- [structuredClone(second)],
- { 0: "a", 1: "b" },
- "baseline",
- ),
- ).toBe(true);
- expect(
- hasAmbiguousTargetChange(
- [first, second],
- [],
- { 0: "a", 1: "b" },
- "baseline",
- ),
- ).toBe(false);
- });
-});
diff --git a/web/src/features/experiments/lib/reconcileFilterTargets.ts b/web/src/features/experiments/lib/reconcileFilterTargets.ts
deleted file mode 100644
index 540a6be71f..0000000000
--- a/web/src/features/experiments/lib/reconcileFilterTargets.ts
+++ /dev/null
@@ -1,130 +0,0 @@
-import type { FilterState } from "@langfuse/shared";
-import isEqual from "lodash/isEqual";
-
-function sameField(left: FilterState[number], right: FilterState[number]) {
- return (
- left.column === right.column &&
- ("key" in left ? left.key : null) === ("key" in right ? right.key : null)
- );
-}
-
-function matchFilterIndices(
- previousFilters: FilterState,
- nextFilters: FilterState,
-) {
- const matched = new Set<number>();
- const matches = new Map<number, number>();
- const match = (nextIndex: number, previousIndex: number) => {
- if (previousIndex < 0) return;
- matched.add(previousIndex);
- matches.set(nextIndex, previousIndex);
- };
-
- // Sidebar removals retain object identity, which distinguishes identical
- // conditions assigned to different runs. Grammar commits reconstruct objects.
- nextFilters.forEach((filter, nextIndex) => {
- match(
- nextIndex,
- previousFilters.findIndex(
- (previous, index) => !matched.has(index) && previous === filter,
- ),
- );
- });
- nextFilters.forEach((filter, nextIndex) => {
- if (matches.has(nextIndex)) return;
- match(
- nextIndex,
- previousFilters.findIndex(
- (previous, index) => !matched.has(index) && isEqual(previous, filter),
- ),
- );
- });
- nextFilters.forEach((filter, nextIndex) => {
- if (matches.has(nextIndex)) return;
- const previousCandidates = previousFilters.flatMap((previous, index) =>
- !matched.has(index) && sameField(previous, filter) ? [index] : [],
- );
- const nextCandidates = nextFilters.filter(
- (next, index) => !matches.has(index) && sameField(next, filter),
- );
- if (previousCandidates.length === 1 && nextCandidates.length === 1) {
- match(nextIndex, previousCandidates[0]!);
- }
- });
-
- return { matched, matches };
-}
-
-/** Keep run assignments attached to conditions when editors reorder, remove or replace them. */
-export function reconcileFilterTargets(
- previousFilters: FilterState,
- nextFilters: FilterState,
- targets: Readonly<Record<number, string>>,
-): Record<number, string> {
- const { matched, matches } = matchFilterIndices(previousFilters, nextFilters);
- const nextTargets: Record<number, string> = {};
- for (const [nextIndex, previousIndex] of matches) {
- const target = targets[previousIndex];
- if (target !== undefined) nextTargets[nextIndex] = target;
- }
- nextFilters.forEach((filter, nextIndex) => {
- if (matches.has(nextIndex)) return;
- const previousCandidates = previousFilters.flatMap((previous, index) =>
- !matched.has(index) && sameField(previous, filter) ? [index] : [],
- );
- const nextCount = nextFilters.filter(
- (next, index) => !matches.has(index) && sameField(next, filter),
- ).length;
- const candidateTargets = new Set(
- previousCandidates.map((index) => targets[index]),
- );
- if (nextCount <= previousCandidates.length && candidateTargets.size === 1) {
- const target = targets[previousCandidates[0]!];
- if (target !== undefined) nextTargets[nextIndex] = target;
- }
- });
- return nextTargets;
-}
-
-/** Reject grammar changes that cannot preserve a condition's experiment assignment. */
-export function hasAmbiguousTargetChange(
- previousFilters: FilterState,
- nextFilters: FilterState,
- targets: Readonly<Record<number, string>>,
- defaultTarget: string | undefined,
-): boolean {
- const removedDuplicate = previousFilters.some((filter) => {
- const previousIndices = previousFilters.flatMap((previous, index) =>
- isEqual(previous, filter) ? [index] : [],
- );
- const remaining = nextFilters.filter((next) =>
- isEqual(next, filter),
- ).length;
- return (
- remaining > 0 &&
- remaining < previousIndices.length &&
- new Set(previousIndices.map((index) => targets[index] ?? defaultTarget))
- .size > 1
- );
- });
- if (removedDuplicate) return true;
-
- const { matched, matches } = matchFilterIndices(previousFilters, nextFilters);
- return nextFilters.some((filter, nextIndex) => {
- if (matches.has(nextIndex)) return false;
- const previousCandidates = previousFilters.flatMap((previous, index) =>
- !matched.has(index) && sameField(previous, filter) ? [index] : [],
- );
- const candidateTargets = new Set(
- previousCandidates.map((index) => targets[index] ?? defaultTarget),
- );
- const nextCount = nextFilters.filter(
- (next, index) => !matches.has(index) && sameField(next, filter),
- ).length;
- return (
- candidateTargets.size > 1 ||
- (nextCount > previousCandidates.length &&
- [...candidateTargets].some((target) => target !== defaultTarget))
- );
- });
-}
diff --git a/web/src/features/filters/hooks/useSidebarFilterState.tsx b/web/src/features/filters/hooks/useSidebarFilterState.tsx
index 4271ebed8c..9baa1c6065 100644
--- a/web/src/features/filters/hooks/useSidebarFilterState.tsx
+++ b/web/src/features/filters/hooks/useSidebarFilterState.tsx
@@ -48,6 +48,7 @@ import {
buildOnlySelection,
clearCategoricalColumn,
deriveOperatorChange,
+ hasMultipleFilterTargets,
removeColumnFiltersOfType,
removeTextFilterEntry,
type BooleanKeyValueFilterEntry,
@@ -1376,6 +1377,17 @@ export function useSidebarFilterPresentation(
};
}
+ if (
+ facet.type === "categorical" &&
+ hasMultipleFilterTargets(filterState, facet.column)
+ ) {
+ return {
+ isDisabled: true,
+ reason:
+ "Edit filters for different targets individually in the filter bar.",
+ };
+ }
+
return { isDisabled: false };
};
@@ -1465,6 +1477,7 @@ export function useSidebarFilterPresentation(
const categoryFilters = filterState.filter(
(f) => f.column === facet.column && f.type === "categoryOptions",
) as Array<{
+ target?: string;
column: string;
type: "categoryOptions";
operator: "any of" | "none of";
@@ -1476,6 +1489,7 @@ export function useSidebarFilterPresentation(
const activeFilters: KeyValueFilterEntry[] = categoryFilters.map(
(f) => ({
key: f.key,
+ ...(f.target ? { target: f.target } : {}),
operator: f.operator,
value: f.value,
}),
@@ -1534,6 +1548,7 @@ export function useSidebarFilterPresentation(
const numericFilters = filterState.filter(
(f) => f.column === facet.column && f.type === "numberObject",
) as Array<{
+ target?: string;
column: string;
type: "numberObject";
operator: "=" | ">" | "<" | ">=" | "<=";
@@ -1545,6 +1560,7 @@ export function useSidebarFilterPresentation(
const activeFilters: NumericKeyValueFilterEntry[] =
numericFilters.map((f) => ({
key: f.key,
+ ...(f.target ? { target: f.target } : {}),
operator: f.operator,
value: f.value,
}));
@@ -1614,6 +1630,7 @@ export function useSidebarFilterPresentation(
const booleanFilters = filterState.filter(
(f) => f.column === facet.column && f.type === "booleanObject",
) as Array<{
+ target?: string;
column: string;
type: "booleanObject";
operator: "=" | "<>";
@@ -1624,6 +1641,7 @@ export function useSidebarFilterPresentation(
const activeFilters: BooleanKeyValueFilterEntry[] =
booleanFilters.map((f) => ({
key: f.key,
+ ...(f.target ? { target: f.target } : {}),
operator: f.operator,
value: f.value,
}));
@@ -1667,6 +1685,7 @@ export function useSidebarFilterPresentation(
const stringFilters = filterState.filter(
(f) => f.column === facet.column && f.type === "stringObject",
) as Array<{
+ target?: string;
column: string;
type: "stringObject";
operator:
@@ -1683,6 +1702,7 @@ export function useSidebarFilterPresentation(
const activeFilters: StringKeyValueFilterEntry[] = stringFilters.map(
(f) => ({
key: f.key,
+ ...(f.target ? { target: f.target } : {}),
operator: f.operator,
value: f.value,
}),
diff --git a/web/src/features/filters/lib/filter-query-encoding-decoding.clienttest.ts b/web/src/features/filters/lib/filter-query-encoding-decoding.clienttest.ts
index c4480dcd11..3a118accde 100644
--- a/web/src/features/filters/lib/filter-query-encoding-decoding.clienttest.ts
+++ b/web/src/features/filters/lib/filter-query-encoding-decoding.clienttest.ts
@@ -644,5 +644,38 @@ describe("Filter Query Encoding & Decoding (Legacy Format)", () => {
expect(deserialized).toEqual(mixedFilters);
});
+
+ it("round-trips an optional target as a sixth field without changing untargeted URLs", () => {
+ const untargeted: FilterState = [
+ {
+ column: "level",
+ type: "stringOptions",
+ operator: "any of",
+ value: ["ERROR"],
+ },
+ ];
+ expect(encodeFilters(untargeted)).toBe(
+ "level;stringOptions;;any of;ERROR",
+ );
+ expect(decodeFilters("level;stringOptions;;any of;ERROR")).toEqual(
+ untargeted,
+ );
+
+ const targeted: FilterState = [
+ {
+ column: "level",
+ type: "stringOptions",
+ operator: "any of",
+ value: ["ERROR"],
+ target: "run-b",
+ },
+ ];
+ expect(encodeFilters(targeted)).toBe(
+ "level;stringOptions;;any of;ERROR;run-b",
+ );
+ expect(decodeFilters("level;stringOptions;;any of;ERROR;run-b")).toEqual(
+ targeted,
+ );
+ });
});
});
diff --git a/web/src/features/filters/lib/sidebar-filter-actions.clienttest.ts b/web/src/features/filters/lib/sidebar-filter-actions.clienttest.ts
index e6a489f492..ebf0b3c66f 100644
--- a/web/src/features/filters/lib/sidebar-filter-actions.clienttest.ts
+++ b/web/src/features/filters/lib/sidebar-filter-actions.clienttest.ts
@@ -57,6 +57,34 @@ const ctx: SidebarFilterActionContext = {
};
describe("applySelection", () => {
+ it("keeps a categorical filter's target and refuses to merge different targets", () => {
+ const current = [
+ {
+ column: "env",
+ type: "stringOptions",
+ operator: "any of",
+ value: ["prod"],
+ target: "run-b",
+ },
+ ] satisfies FilterState;
+ expect(applyCheckboxSelection(ctx, current, "env", ["dev"])).toEqual([
+ { ...current[0], value: ["dev"] },
+ ]);
+ const text = addTextFilterEntry(current, "env", "contains", "dev")!;
+ expect(text[0].target).toBe("run-b");
+ expect(applyCheckboxSelection(ctx, text, "env", ["dev"])[0].target).toBe(
+ "run-b",
+ );
+ const multiple: FilterState = [
+ ...current,
+ { ...current[0], target: "baseline", value: ["test"] },
+ ];
+ expect(applyCheckboxSelection(ctx, multiple, "env", ["dev"])).toEqual(
+ multiple,
+ );
+ expect(addTextFilterEntry(multiple, "env", "contains", "dev")).toBeNull();
+ });
+
it("returns current for unknown columns and non-enumerable options", () => {
const current: FilterState = [];
expect(applySelection(ctx, current, "nope", ["x"])).toBe(current);
diff --git a/web/src/features/filters/lib/sidebar-filter-actions.ts b/web/src/features/filters/lib/sidebar-filter-actions.ts
index c3ad0fadc0..e0871a1525 100644
--- a/web/src/features/filters/lib/sidebar-filter-actions.ts
+++ b/web/src/features/filters/lib/sidebar-filter-actions.ts
@@ -44,6 +44,7 @@ export type SidebarFilterActionContext = {
// Represents one active filter row in the key-value facet UI
// Example: key="accuracy", operator="any of", value=["good", "excellent"]
export type KeyValueFilterEntry = {
+ target?: string;
key: string;
operator: "any of" | "none of";
value: string[];
@@ -52,12 +53,14 @@ export type KeyValueFilterEntry = {
// Represents one active numeric filter row in the numeric key-value facet UI
// Example: key="accuracy", operator=">=", value=0.8
export type NumericKeyValueFilterEntry = {
+ target?: string;
key: string;
operator: "=" | ">" | "<" | ">=" | "<=";
value: number | "";
};
export type BooleanKeyValueFilterEntry = {
+ target?: string;
key: string;
operator: "=" | "<>";
value: boolean | "";
@@ -67,6 +70,7 @@ export type BooleanKeyValueFilterEntry = {
// Example: key="environment", operator="=", value="production". `is set` /
// `is not set` are value-less key-presence operators (value stays "").
export type StringKeyValueFilterEntry = {
+ target?: string;
key: string;
operator: "=" | "contains" | "does not contain" | "is set" | "is not set";
value: string;
@@ -174,6 +178,20 @@ export function resolveCheckboxOperator(params: {
return { finalOperator: "any of", finalValues: values };
}
+/** A single checkbox selection cannot represent conditions for different targets. */
+export function hasMultipleFilterTargets(
+ filters: FilterState,
+ column: string,
+): boolean {
+ return (
+ new Set(
+ filters
+ .filter((filter) => filter.column === column)
+ .map((filter) => filter.target),
+ ).size > 1
+ );
+}
+
/**
* Applies a checkbox/boolean facet selection to the state. Returns `current`
* unchanged when the column is unknown or its options are not enumerable.
@@ -185,6 +203,11 @@ export function applySelection(
values: string[],
operator?: CheckboxOperator,
): FilterState {
+ if (hasMultipleFilterTargets(current, column)) return current;
+ const existingFilter = current.find((f) => f.column === column);
+ const target = existingFilter?.target
+ ? { target: existingFilter.target }
+ : {};
const other = current.filter((f) => f.column !== column);
const facet = ctx.facets.find((f) => f.column === column);
@@ -207,6 +230,7 @@ export function applySelection(
...other,
{
column,
+ ...target,
type: "boolean" as const,
operator: "=" as const,
value: !invert,
@@ -218,6 +242,7 @@ export function applySelection(
...other,
{
column,
+ ...target,
type: "boolean" as const,
operator: "=" as const,
value: !!invert,
@@ -244,7 +269,6 @@ export function applySelection(
// Determine operator and values based on context
let finalOperator: CheckboxOperator;
let finalValues: string[];
- const existingFilter = current.find((f) => f.column === column);
const isManagedEnvironmentColumn = column === ctx.managedEnvironmentColumn;
// For an active "none of" filter, "all checked" is not the same as
// "no filter": exclusions outside the current option list may still be
@@ -293,6 +317,7 @@ export function applySelection(
...other,
{
column,
+ ...target,
type: "stringOptions" as const,
operator: "any of" as const,
value: values,
@@ -347,6 +372,7 @@ export function applySelection(
...other,
{
column,
+ ...target,
type: "arrayOptions" as const,
operator: finalOperator,
value: finalValues,
@@ -365,6 +391,7 @@ export function applySelection(
...other,
{
column,
+ ...target,
type: "stringOptions" as const,
operator: stringOperator,
value: finalValues,
@@ -383,6 +410,7 @@ export function applyCheckboxSelection(
values: string[],
operator?: CheckboxOperator,
): FilterState {
+ if (hasMultipleFilterTargets(current, column)) return current;
const withoutTextFilters = current.filter(
(f) =>
!(
@@ -391,7 +419,19 @@ export function applyCheckboxSelection(
(f.operator === "contains" || f.operator === "does not contain")
),
);
- return applySelection(ctx, withoutTextFilters, column, values, operator);
+ const next = applySelection(
+ ctx,
+ withoutTextFilters,
+ column,
+ values,
+ operator,
+ );
+ const target = current.find((filter) => filter.column === column)?.target;
+ return target
+ ? next.map((filter) =>
+ filter.column === column ? { ...filter, target } : filter,
+ )
+ : next;
}
/**
@@ -532,7 +572,8 @@ export function addTextFilterEntry(
operator: TextFilterOperator,
value: string,
): FilterState | null {
- if (!value.trim()) return null;
+ if (!value.trim() || hasMultipleFilterTargets(current, column)) return null;
+ const target = current.find((filter) => filter.column === column)?.target;
const withoutCheckboxFilters = current.filter(
(f) =>
@@ -546,6 +587,7 @@ export function addTextFilterEntry(
...withoutCheckboxFilters,
{
column,
+ ...(target ? { target } : {}),
type: "string",
operator,
value: value.trim(),
@@ -560,6 +602,7 @@ export function removeTextFilterEntry(
operator: TextFilterOperator,
value: string,
): FilterState {
+ if (hasMultipleFilterTargets(current, column)) return current;
return current.filter(
(f) =>
!(
@@ -614,6 +657,7 @@ export function applyKeyedFilterEntries(
type: "categoryOptions" as const,
operator: entry.operator,
key: entry.key,
+ ...(entry.target ? { target: entry.target } : {}),
value: entry.value,
})),
];
@@ -627,6 +671,7 @@ export function applyKeyedFilterEntries(
type: "numberObject" as const,
operator: entry.operator,
key: entry.key,
+ ...(entry.target ? { target: entry.target } : {}),
value: entry.value as number,
})),
];
@@ -640,6 +685,7 @@ export function applyKeyedFilterEntries(
type: "booleanObject" as const,
operator: entry.operator,
key: entry.key,
+ ...(entry.target ? { target: entry.target } : {}),
value: entry.value as boolean,
})),
];
@@ -658,6 +704,7 @@ export function applyKeyedFilterEntries(
type: "stringObject" as const,
operator: entry.operator,
key: entry.key,
+ ...(entry.target ? { target: entry.target } : {}),
// Presence operators carry no value.
value: isStringPresenceOperator(entry.operator) ? "" : entry.value,
})),
diff --git a/web/src/features/search-bar/README.md b/web/src/features/search-bar/README.md
index b8399aa881..55e4613dde 100644
--- a/web/src/features/search-bar/README.md
+++ b/web/src/features/search-bar/README.md
@@ -51,6 +51,35 @@ Cross-field OR, negated groups, and other shapes the flat contract cannot
represent are commit-blocking diagnostics, not silent drops. There is no
FTS `*` operator: the events tRPC filter contract has none.
+**Experiment scopes.** Comparison registries can attach a target to each
+condition, independently of its field and value:
+
+- `"All experiments".scores.quality:>0.8` applies to all currently selected experiments.
+ Unqualified typed filters acquire this visible prefix when committed.
+- `baseline.scores.quality:>0.8` follows the currently selected baseline.
+- `"Run A".scores.quality:<0.6` stays pinned to that experiment.
+- `"Run A".eventMetadata."model name":test` uses the same target syntax for
+ metadata. `itemMetadata.` and `eventMetadata.` map to separate host-declared
+ columns through `metadataNamespaces`.
+- `baseline.has:itemMetadata.region` / `-baseline.has:itemMetadata.region`
+ preserve the sidebar's metadata-key "is set" / "is not set" operators.
+
+`all.` is accepted as a legacy alias and serialized as `"All experiments".`. Experiment names are
+quoted; a real experiment named `baseline` is therefore distinct from the
+symbolic `baseline` keyword. Legacy `field:value @baseline` and
+`field:value @"Run A"` expressions still parse; the serializer emits prefixes.
+The AST stores target and field separately, and lowering resolves the target
+to a stable ID in `FilterState.target`. Targetless persisted filters use the
+registry's `legacyDefaultTarget`, while newly typed unqualified filters use
+`defaultTarget`. Unavailable or ambiguous names block commit.
+
+Target choices augment field/value suggestions when editing a condition. Sidebar
+and search use the same combined options response for the selected experiments.
+Changing the scope changes only the target, not the score's operator or value.
+An unresolved options request blocks score commits. Conditions are AND-joined
+inside each experiment's request group;
+the backend's existing qualification and baseline-visibility rules are unchanged.
+
**Full-text search.** Each registry declares `defaultSearchType` and
`searchScopes`. The adapter writes the existing `searchQuery` / `searchType`
contract; it does not introduce backend filter columns or change matching rules.
diff --git a/web/src/features/search-bar/components/AutocompleteListbox.tsx b/web/src/features/search-bar/components/AutocompleteListbox.tsx
index 524cd0a446..4f068ffc5c 100644
--- a/web/src/features/search-bar/components/AutocompleteListbox.tsx
+++ b/web/src/features/search-bar/components/AutocompleteListbox.tsx
@@ -130,7 +130,10 @@ export function AutocompleteListbox({
>
<OptionIcon kind={o.kind} />
<span
- className="max-w-[480px] min-w-0 flex-none truncate"
+ className={cn(
+ "max-w-[480px] min-w-0 flex-none truncate",
+ o.kind === "pattern" && o.textClassName,
+ )}
title={o.label}
>
{o.label}
diff --git a/web/src/features/search-bar/components/ComposerTokens.stories.tsx b/web/src/features/search-bar/components/ComposerTokens.stories.tsx
index 3cde809dbd..5a6510a9f6 100644
--- a/web/src/features/search-bar/components/ComposerTokens.stories.tsx
+++ b/web/src/features/search-bar/components/ComposerTokens.stories.tsx
@@ -1,5 +1,6 @@
import preview from "../../../../.storybook/preview";
import { ComposerTokens } from "./ComposerTokens";
+import { EVENTS_FIELD_REGISTRY } from "../lib/fields";
const meta = preview.meta({
component: ComposerTokens,
@@ -34,3 +35,20 @@ export const FreeTextAndScopes = meta.story({
export const InvalidRevealed = meta.story({
args: { draft: "level:ERROR nope:1", showDiagnostics: true },
});
+
+export const ExperimentTargetPrefix = meta.story({
+ args: {
+ draft: '-"Run: A".scores."Rouge Score":>0.8',
+ showDiagnostics: true,
+ registry: {
+ ...EVENTS_FIELD_REGISTRY,
+ targeting: {
+ defaultTarget: "all",
+ supports: () => true,
+ targets: [
+ { id: "run-a", label: "Run: A", textClassName: "text-pink-500" },
+ ],
+ },
+ },
+ },
+});
diff --git a/web/src/features/search-bar/components/ComposerTokens.tsx b/web/src/features/search-bar/components/ComposerTokens.tsx
index ed198ae5a6..80aa63af8f 100644
--- a/web/src/features/search-bar/components/ComposerTokens.tsx
+++ b/web/src/features/search-bar/components/ComposerTokens.tsx
@@ -74,8 +74,17 @@ function renderPlainText(text: string, keyPrefix: string): React.ReactNode[] {
}
function FilterTokenBody({ segment }: { segment: FilterSegment }) {
- const raw = segment.raw;
+ const raw = segment.target
+ ? segment.raw.slice(0, segment.target.from) +
+ segment.raw.slice(segment.target.to)
+ : segment.raw;
const dash = segment.negated ? "-" : "";
+ const prefixTarget = segment.target && segment.target.from <= dash.length;
+ const targetText = segment.target ? (
+ <span data-part="target" className={segment.target.textClassName}>
+ {segment.raw.slice(segment.target.from, segment.target.to)}
+ </span>
+ ) : null;
const body = segment.negated ? raw.slice(1) : raw;
// Quote-aware split: a dot-path key may carry a quoted segment with an inner
// colon (`metadata."foo:bar":*x*`), so the field/value separator is the first
@@ -96,6 +105,7 @@ function FilterTokenBody({ segment }: { segment: FilterSegment }) {
The value stays outside so long grouped values can still wrap. */}
<span className="whitespace-nowrap">
{dash && <span className="text-muted-foreground">-</span>}
+ {prefixTarget && targetText}
<span data-part="field" className="text-qlang-field">
{segment.displayField}
</span>
@@ -109,6 +119,7 @@ function FilterTokenBody({ segment }: { segment: FilterSegment }) {
>
{value}
</span>
+ {!prefixTarget && targetText}
</>
);
}
diff --git a/web/src/features/search-bar/hooks/useEventsSearchBar.ts b/web/src/features/search-bar/hooks/useEventsSearchBar.ts
index d459d939f9..f51b98cc54 100644
--- a/web/src/features/search-bar/hooks/useEventsSearchBar.ts
+++ b/web/src/features/search-bar/hooks/useEventsSearchBar.ts
@@ -132,12 +132,6 @@ function restingDraft(text: string): string {
return text.length === 0 ? text : `${text} `;
}
-/** Column + key identity, so keyed filters (metadata.<k>, scores.<k>) on the
- * same column don't collide while plain columns dedupe by column alone. */
-function filterIdentity(f: FilterState[number]): string {
- return `${f.column}\u0000${"key" in f ? f.key : ""}`;
-}
-
export function useEventsSearchBar({
projectId,
tableName,
@@ -286,17 +280,12 @@ export function useEventsSearchBar({
const searchTypeRef = useRef(searchType);
searchTypeRef.current = searchType;
- // Re-attach the filters the grammar can't represent so neither a grammar
- // commit nor an AI apply ever drops them (no-silent-drop contract) — but drop
- // any skipped filter whose (column, key) the new set just produced, so an
- // explicit edit replaces it instead of duplicating the column in URL state.
- const mergeWithSkipped = useCallback((filters: FilterState): FilterState => {
- const producedKeys = new Set(filters.map((f) => filterIdentity(f)));
- const preserved = skippedFiltersRef.current.filter(
- (f) => !producedKeys.has(filterIdentity(f)),
- );
- return preserved.length > 0 ? [...filters, ...preserved] : filters;
- }, []);
+ /** Preserve hidden filters unless the same target, column, and key is edited. */
+ const mergeWithSkipped = useCallback(
+ (filters: FilterState): FilterState =>
+ mergeSkippedFilters(filters, skippedFiltersRef.current),
+ [],
+ );
const beginCommit = useCallback(
(next: AppliedSearchState) => {
@@ -478,3 +467,22 @@ export function useEventsSearchBar({
return { store, commit, applyFilters, resetDraft };
}
+
+function mergeSkippedFilters(
+ filters: FilterState,
+ skippedFilters: FilterState,
+): FilterState {
+ const producedKeys = new Set(filters.map((f) => filterIdentity(f)));
+ const preserved = skippedFilters.filter(
+ (f) => !producedKeys.has(filterIdentity(f)),
+ );
+ return preserved.length > 0 ? [...filters, ...preserved] : filters;
+}
+
+function filterIdentity(filter: FilterState[number]): string {
+ return JSON.stringify([
+ filter.target ?? null,
+ filter.column,
+ "key" in filter ? filter.key : null,
+ ]);
+}
diff --git a/web/src/features/search-bar/lib/adapter.ts b/web/src/features/search-bar/lib/adapter.ts
index 6de1fb4722..7b0dfd282c 100644
--- a/web/src/features/search-bar/lib/adapter.ts
+++ b/web/src/features/search-bar/lib/adapter.ts
@@ -21,6 +21,7 @@
// - NOT lowers at this boundary (none-of / does-not-contain / inverted
// comparisons / inverted booleans); gaps error via fields.negationIssue.
+import { resolveAttachedTarget } from "./targeting";
import { type FilterState, type TracingSearchType } from "@langfuse/shared";
import type { ASTNode, FilterNode } from "./ast";
@@ -115,7 +116,7 @@ function isObservedBooleanScore(
function collapseSameFieldOr(node: ASTNode): FilterNode | null {
if (node.kind !== "or") return null;
const filters = node.children.filter(
- (c): c is FilterNode => c.kind === "filter",
+ (c): c is FilterNode => c.kind === "filter" && !c.target,
);
if (filters.length !== node.children.length || filters.length < 2)
return null;
@@ -302,6 +303,10 @@ function lowerFilterNode(
ref?.type === "searchScope" ||
(ref?.type === "pseudo" && ref.id === "in")
) {
+ if (node.target) {
+ ctx.errors.push("Search scopes do not support a target");
+ return;
+ }
if (node.values.length === 0) return;
const issue =
operatorIssue(ref, node.op, node.valueOp ?? "or") ??
@@ -372,6 +377,12 @@ function lowerFilter(
scoreTypes?: ScoreTypeContext,
registry: FieldRegistry = EVENTS_FIELD_REGISTRY,
): void {
+ const target = resolveAttachedTarget(node, registry);
+ if (target && "error" in target) {
+ errors.push(target.error);
+ return;
+ }
+
if (node.values.length === 0) {
// The parser already flags every empty-value FilterNode at this span — and
// with the exact wording for each shape (bare key, operator prefix
@@ -400,33 +411,53 @@ function lowerFilter(
}
}
+ // One node can emit several conditions (multi-value, score expansion), so
+ // stamp a resolved target onto each before appending.
+ const conditions: SingleEventsFilter[] = [];
switch (ref.type) {
case "pseudo":
// Global search scopes are handled by lowerFilterNode.
- lowerHas(node, negated, out, errors, registry);
- return;
+ lowerHas(node, negated, conditions, errors, registry);
+ break;
case "metadata":
- lowerMetadata(node, ref.key, negated, out, errors);
- return;
+ lowerMetadata(node, ref.key, negated, conditions, errors, ref.column);
+ break;
case "scores":
- lowerScores(node, ref.key, ref.level, negated, out, errors, scoreTypes);
- return;
+ if (registry.targeting?.scoreTypesError) {
+ errors.push(registry.targeting.scoreTypesError);
+ return;
+ }
+ lowerScores(
+ node,
+ ref.key,
+ ref.level,
+ negated,
+ conditions,
+ errors,
+ scoreTypes,
+ );
+ break;
case "field":
switch (ref.field.kind) {
case "number":
- lowerNumber(node, ref.field, negated, out, errors);
- return;
+ lowerNumber(node, ref.field, negated, conditions, errors);
+ break;
case "datetime":
- lowerDatetime(node, ref.field, negated, out, errors);
- return;
+ lowerDatetime(node, ref.field, negated, conditions, errors);
+ break;
case "boolean":
- lowerBoolean(node, ref.field, negated, out, errors);
- return;
+ lowerBoolean(node, ref.field, negated, conditions, errors);
+ break;
case "text":
- lowerText(node, ref.field, negated, out, errors);
- return;
+ lowerText(node, ref.field, negated, conditions, errors);
+ break;
}
}
+ out.push(
+ ...conditions.map((condition) =>
+ target ? { ...condition, target: target.id } : condition,
+ ),
+ );
}
/** AST string op -> Langfuse string filter operator (positive polarity). */
@@ -714,6 +745,7 @@ function lowerMetadata(
negated: boolean,
out: SingleEventsFilter[],
errors: string[],
+ column = "metadata",
): void {
if (node.values.length > 1) {
errors.push(
@@ -726,7 +758,7 @@ function lowerMetadata(
if (node.op === "~") {
out.push({
type: "stringObject",
- column: "metadata",
+ column,
key,
operator: negated ? "does not contain" : "contains",
value,
@@ -737,7 +769,7 @@ function lowerMetadata(
// negationIssue blocks negated forms before this point.
out.push({
type: "stringObject",
- column: "metadata",
+ column,
key,
operator: stringOperatorOf(node.op)!,
value,
@@ -755,7 +787,7 @@ function lowerMetadata(
}
out.push({
type: "stringObject",
- column: "metadata",
+ column,
key,
operator: "=",
value,
@@ -944,6 +976,16 @@ function lowerHas(
}
for (const v of node.values) {
const target = registry.resolveField(v);
+ if (target?.type === "metadata") {
+ out.push({
+ type: "stringObject",
+ column: target.column ?? "metadata",
+ key: target.key,
+ operator: negated ? "is not set" : "is set",
+ value: "",
+ });
+ continue;
+ }
if (target === null || target.type !== "field") {
errors.push(`has: expects a field name, got "${v}"`);
continue;
diff --git a/web/src/features/search-bar/lib/ast.ts b/web/src/features/search-bar/lib/ast.ts
index 907124a1b8..394a40a095 100644
--- a/web/src/features/search-bar/lib/ast.ts
+++ b/web/src/features/search-bar/lib/ast.ts
@@ -34,6 +34,7 @@ type NotNode = {
parenSpan?: Span;
};
export type FilterNode = {
+ target?: { kind: "name" | "keyword"; value: string; span?: Span };
kind: "filter";
/** Canonical field id (registry-resolved) or `metadata.<key>`. */
key: string;
@@ -79,6 +80,8 @@ export function astEquals(a: ASTNode | null, b: ASTNode | null): boolean {
const o = b as FilterNode;
return (
a.key === o.key &&
+ a.target?.kind === o.target?.kind &&
+ a.target?.value === o.target?.value &&
a.op === o.op &&
(a.valueOp ?? "or") === (o.valueOp ?? "or") &&
a.values.length === o.values.length &&
diff --git a/web/src/features/search-bar/lib/commit.ts b/web/src/features/search-bar/lib/commit.ts
index 0af665d137..0fa7e9cdf1 100644
--- a/web/src/features/search-bar/lib/commit.ts
+++ b/web/src/features/search-bar/lib/commit.ts
@@ -17,6 +17,7 @@ import {
type ScoreTypeContext,
} from "./adapter";
import { serialize, type Diagnostic } from "./langQ";
+import { filterStateToQueryText } from "./filter-state-to-query";
import { validateQuery } from "./validate";
// The full Events default. Other hosts declare their own defaultSearchType
@@ -76,7 +77,10 @@ export function planCommit(
filters,
searchQuery,
searchType: searchType ?? [...registry.defaultSearchType],
- canonical: serialize(res.ast, registry),
+ canonical: registry.targeting
+ ? filterStateToQueryText(filters, { searchQuery, searchType }, registry)
+ .text
+ : serialize(res.ast, registry),
};
}
diff --git a/web/src/features/search-bar/lib/completions.clienttest.ts b/web/src/features/search-bar/lib/completions.clienttest.ts
index 853c257944..4041ae1f10 100644
--- a/web/src/features/search-bar/lib/completions.clienttest.ts
+++ b/web/src/features/search-bar/lib/completions.clienttest.ts
@@ -48,6 +48,60 @@ function plan(
});
}
+describe("experiment target completions", () => {
+ const registry = createFieldRegistry({
+ ...EVENTS_FIELD_REGISTRY,
+ targeting: {
+ defaultTarget: "all",
+ supports: () => true,
+ targets: [
+ {
+ id: "all",
+ label: "All experiments",
+ displayLabel: "All experiments",
+ keyword: true,
+ },
+ {
+ id: "baseline",
+ label: "baseline",
+ displayLabel: "Baseline",
+ keyword: true,
+ },
+ { id: "run-a", label: "Run A" },
+ ],
+ },
+ });
+ const targetedPlan = (input: string, caret = input.length) =>
+ planInputCompletions(
+ {
+ input,
+ caret,
+ observed: OBSERVED,
+ recents: [],
+ currentQueryText: input,
+ },
+ registry,
+ );
+
+ it("changes scope on one condition and preserves another condition", () => {
+ const input = "baseline.level:ERROR scores.accuracy:>0.8";
+ const p = targetedPlan(input, 18)!;
+ const option = flattenOptions(p).find(
+ (option) => option.id === "target:run-a",
+ )!;
+ if (option.kind !== "pattern")
+ throw new Error("Expected experiment option");
+ expect(applyPick(option, input, p).next).toBe(
+ '"Run A".level:ERROR scores.accuracy:>0.8',
+ );
+ const all = flattenOptions(p).find((option) => option.id === "target:all")!;
+ if (all.kind !== "pattern") throw new Error("Expected experiment option");
+ expect(applyPick(all, input, p).next).toBe(
+ '"All experiments".level:ERROR scores.accuracy:>0.8',
+ );
+ });
+});
+
describe("planInputCompletions", () => {
it("offers only declared scope rewrites and keeps compatibility in: out of suggestions", () => {
const registry = createFieldRegistry({
diff --git a/web/src/features/search-bar/lib/completions.ts b/web/src/features/search-bar/lib/completions.ts
index 6bfdb88174..08d7fff7fa 100644
--- a/web/src/features/search-bar/lib/completions.ts
+++ b/web/src/features/search-bar/lib/completions.ts
@@ -16,11 +16,13 @@ import {
indexOfOutsideQuotes,
lexTokens,
parseGlob,
+ parse,
serializeValue,
splitOutsideQuotes,
termAt,
} from "./langQ";
import {
+ canonicalKey,
EVENTS_FIELD_REGISTRY,
SCORE_COLUMNS,
type FieldDef,
@@ -28,6 +30,14 @@ import {
type FieldRef,
} from "./fields";
import { quoteIfNeeded } from "./quoting";
+import {
+ readTargetPrefix,
+ resolveFilterTarget,
+ supportsFilterTarget,
+ serializeTarget,
+ targetReference,
+} from "./targeting";
+import type { ASTNode, FilterNode } from "./ast";
import { validateQuery } from "./validate";
import { rankFilter } from "./rank";
import type { ObservedOptions } from "./observed-options";
@@ -64,8 +74,11 @@ export type CompletionOption =
id: string;
kind: "pattern";
label: string;
+ textClassName?: string;
detail?: string;
insert: string;
+ /** Incomplete target or field prefixes keep the caret inside the term. */
+ requiresInput?: boolean;
/** When set, the pick replaces THIS span instead of the plan's — used by
* scope rewrites that wrap the whole coalesced free-text run, not just
* the token under the caret. */
@@ -234,6 +247,17 @@ function fieldOptions(
fieldId: "metadata.",
});
}
+ if (includeVirtual) {
+ for (const namespace of Object.keys(registry.metadataNamespaces ?? {})) {
+ opts.push({
+ id: `field:${namespace}.`,
+ kind: "field",
+ label: `${namespace}.`,
+ detail: `${namespace} key path`,
+ fieldId: `${namespace}.`,
+ });
+ }
+ }
if (includeVirtual && registry.scores) {
opts.push(
// `scores.` is level-agnostic (LFE-10596): one entry point for every
@@ -656,6 +680,7 @@ type PathKind = {
prefix: string;
canonical: string;
level?: "observation" | "trace";
+ metadataColumn?: string;
};
// Must mirror fields.ts TRACE_SCORE_PREFIXES / resolveField — every alias the
@@ -676,6 +701,17 @@ function pathKindOf(
registry: FieldRegistry,
): { kind: PathKind; typedKey: string } | null {
const lower = keyPart.toLowerCase();
+ for (const [namespace, column] of Object.entries(
+ registry.metadataNamespaces ?? {},
+ )) {
+ const prefix = `${namespace}.`;
+ if (lower.startsWith(prefix.toLowerCase())) {
+ return {
+ kind: { prefix, canonical: prefix, metadataColumn: column },
+ typedKey: keyPart.slice(prefix.length),
+ };
+ }
+ }
for (const kind of PATH_PREFIXES) {
if (kind.canonical === "metadata." && !registry.metadata) continue;
if (kind.canonical === "scores." && !registry.scores) continue;
@@ -706,11 +742,14 @@ function keyPathOptions(
// still matches (otherwise the first `"` drops every option and the popover
// silently closes).
const rankKey = typedKey.replace(/^"/, "").replace(/"$/, "");
- if (kind.canonical === "metadata.") {
- const options = observedValues(observed, "metadata").map((o) => ({
- id: `key:metadata.${o.value}`,
+ if (kind.canonical === "metadata." || kind.metadataColumn) {
+ const options = observedValues(
+ observed,
+ kind.metadataColumn ?? "metadata",
+ ).map((o) => ({
+ id: `key:${kind.canonical}${o.value}`,
kind: "field" as const,
- label: `metadata.${o.value}`,
+ label: `${kind.canonical}${o.value}`,
// The observed JSON type of the path (display-only — metadata filters
// always lower to stringObject regardless). Paths seen with multiple
// types carry no type hint; counts stay the fallback like other lists.
@@ -719,7 +758,7 @@ function keyPathOptions(
}));
return {
title: SECTION_KEYS,
- options: rankFilter(options, `metadata.${rankKey}`),
+ options: rankFilter(options, `${kind.canonical}${rankKey}`),
};
}
const numericColumn =
@@ -836,7 +875,32 @@ function valueStageSections(input: ValueStageInput): {
(observed === undefined || !(column in observed));
// An operator prefix was already typed: the rest is free-form entry.
- if (valuePrefix.length > 0) return null;
+ const metadataPresence: CompletionOption[] =
+ ref.type === "metadata"
+ ? [
+ {
+ id: "presence:set",
+ kind: "pattern",
+ label: "is set",
+ insert: `has:${canonicalKey(ref)}`,
+ replaceSpan: tokenSpan,
+ },
+ {
+ id: "presence:missing",
+ kind: "pattern",
+ label: "is not set",
+ insert: `-has:${canonicalKey(ref)}`,
+ replaceSpan: tokenSpan,
+ },
+ ]
+ : [];
+ if (valuePrefix.length > 0)
+ return metadataPresence.length > 0
+ ? {
+ sections: section(SECTION_PRESENCE, metadataPresence),
+ loading: false,
+ }
+ : null;
switch (ref.type) {
case "searchScope":
@@ -858,6 +922,20 @@ function valueStageSections(input: ValueStageInput): {
detail: f.description,
value: f.id,
}));
+ const metadataRoots = Object.entries(registry.metadataNamespaces ?? {});
+ if (registry.metadata) metadataRoots.unshift(["metadata", "metadata"]);
+ for (const [namespace, column] of metadataRoots) {
+ for (const option of observedValues(observed, column)) {
+ const path = `${namespace}.${quoteIfNeeded(option.value)}`;
+ all.push({
+ id: `value:${path}`,
+ kind: "value",
+ label: path,
+ detail: "Metadata key presence",
+ value: path,
+ });
+ }
+ }
return {
sections: section(SECTION_VALUES, valueOptions(all, typed)),
loading: false,
@@ -865,8 +943,15 @@ function valueStageSections(input: ValueStageInput): {
}
case "metadata": {
- if (observed === undefined) return { sections: [], loading: true };
- const all = observedValues(observed, `metadata.${ref.key}`).map((o) => ({
+ if (observed === undefined)
+ return {
+ sections: section(SECTION_PRESENCE, metadataPresence),
+ loading: true,
+ };
+ const all = observedValues(
+ observed,
+ `${ref.column ?? "metadata"}.${ref.key}`,
+ ).map((o) => ({
id: `value:${o.value}`,
kind: "value" as const,
label: o.value,
@@ -875,11 +960,11 @@ function valueStageSections(input: ValueStageInput): {
}));
const values = valueOptions(all, typed);
const ops = typed.length > 0 ? matchOperatorOptions(typed, negated) : [];
- if (values.length + ops.length === 0) return null;
return {
sections: [
...section(SECTION_VALUES, values),
...section(SECTION_MATCH_OPS, ops),
+ ...section(SECTION_PRESENCE, metadataPresence),
],
loading: false,
};
@@ -1290,6 +1375,186 @@ function scopeSwitchOptions(
}));
}
+function filterAt(node: ASTNode | null, caret: number): FilterNode | null {
+ if (!node) return null;
+ if (node.kind === "not") return filterAt(node.child, caret);
+ if (node.kind === "and" || node.kind === "or") {
+ for (const child of node.children) {
+ const found = filterAt(child, caret);
+ if (found) return found;
+ }
+ return null;
+ }
+ return node.kind === "filter" &&
+ node.span &&
+ caret >= node.span.from &&
+ caret <= node.span.to
+ ? node
+ : null;
+}
+
+/** Field picks show the default scope immediately, including unfinished filters. */
+export function planInputCompletions(
+ ctx: InputCompletionContext,
+ registry: FieldRegistry = EVENTS_FIELD_REGISTRY,
+): CompletionPlan | null {
+ const plan = planTargetedInputCompletions(ctx, registry);
+ const capability = registry.targeting;
+ if (!plan || !capability) return plan;
+ const term = termAt(ctx.input, ctx.caret);
+ const raw = term?.raw.replace(/^-/, "") ?? "";
+ if (
+ readTargetPrefix(raw, registry) ||
+ filterAt(parse(ctx.input, registry).ast, ctx.caret)?.target
+ )
+ return plan;
+ const target = capability.targets.find(
+ (entry) => entry.id === capability.defaultTarget,
+ );
+ if (!target) return plan;
+ const prefix = serializeTarget(targetReference(target));
+ return {
+ ...plan,
+ sections: plan.sections.map((section) => ({
+ ...section,
+ options: section.options.map((option) => {
+ if (option.kind !== "field") return option;
+ const ref = registry.resolveField(
+ option.fieldId.endsWith(".")
+ ? `${option.fieldId}key`
+ : option.fieldId,
+ );
+ return ref && capability.supports(ref)
+ ? { ...option, fieldId: `${prefix}${option.fieldId}` }
+ : option;
+ }),
+ })),
+ };
+}
+
+/** Targets augment the existing field/value planner; both edit the same condition. */
+function planTargetedInputCompletions(
+ ctx: InputCompletionContext,
+ registry: FieldRegistry = EVENTS_FIELD_REGISTRY,
+): CompletionPlan | null {
+ const capability = registry.targeting;
+ if (!capability) return planUnscopedInputCompletions(ctx, registry);
+ const term = termAt(ctx.input, ctx.caret);
+ if (!term) return planUnscopedInputCompletions(ctx, registry);
+ const condition = filterAt(parse(ctx.input, registry).ast, ctx.caret);
+ const negated = term.raw.startsWith("-");
+ const bodyFrom = term.from + (negated ? 1 : 0);
+ const prefix = readTargetPrefix(
+ negated ? term.raw.slice(1) : term.raw,
+ registry,
+ );
+ if (!prefix && (!condition || !supportsFilterTarget(condition, registry))) {
+ return planUnscopedInputCompletions(ctx, registry);
+ }
+ const resolved = condition
+ ? resolveFilterTarget(condition, registry)
+ : undefined;
+ const reference = condition?.target ?? prefix?.target;
+ const targetId =
+ resolved && "id" in resolved
+ ? resolved.id
+ : (capability.targets.find(
+ (target) =>
+ reference &&
+ target.label === reference.value &&
+ Boolean(target.keyword) === (reference.kind === "keyword"),
+ )?.id ?? capability.defaultTarget);
+ const insideTarget = prefix && ctx.caret < bodyFrom + prefix.length;
+ let plan: CompletionPlan | null = null;
+ if (!insideTarget && !prefix?.incomplete && !term.raw.startsWith("@")) {
+ const length = prefix?.length ?? 0;
+ const unscoped = {
+ ...ctx,
+ input: ctx.input.slice(0, bodyFrom) + ctx.input.slice(bodyFrom + length),
+ caret: Math.max(bodyFrom, ctx.caret - length),
+ };
+ plan = planUnscopedInputCompletions(unscoped, registry);
+ if (plan && length) {
+ const shift = (position: number) =>
+ position >= bodyFrom ? position + length : position;
+ plan = {
+ ...plan,
+ from: shift(plan.from),
+ to: shift(plan.to),
+ sections: plan.sections.map((section) => ({
+ ...section,
+ options: section.options.map((option) => {
+ if (option.kind !== "pattern" || !option.replaceSpan) return option;
+ const replacesTerm =
+ option.replaceSpan.from === term.from &&
+ option.replaceSpan.to === term.to - length;
+ if (replacesTerm) {
+ const targetText = ctx.input.slice(bodyFrom, bodyFrom + length);
+ const insert = option.insert.startsWith("-")
+ ? `-${targetText}${option.insert.slice(1)}`
+ : `${targetText}${option.insert}`;
+ return {
+ ...option,
+ insert,
+ replaceSpan: { from: term.from, to: term.to },
+ };
+ }
+ return {
+ ...option,
+ replaceSpan: {
+ from: shift(option.replaceSpan.from),
+ to: shift(option.replaceSpan.to),
+ },
+ };
+ }),
+ })),
+ };
+ }
+ }
+ const span = condition?.span ?? { from: bodyFrom, to: term.to };
+ let fieldText = ctx.input.slice(span.from, span.to);
+ if (condition?.target?.span) {
+ const targetSpan = condition.target.span;
+ fieldText = (
+ ctx.input.slice(span.from, targetSpan.from) +
+ ctx.input.slice(targetSpan.to, span.to)
+ ).trimEnd();
+ } else if (prefix) {
+ fieldText = fieldText.slice(prefix.length);
+ }
+ const partialName = prefix?.incomplete
+ ? prefix.target.value.toLowerCase()
+ : "";
+ const options: CompletionOption[] = capability.targets
+ .filter(
+ (target) =>
+ target.keyword || target.label.toLowerCase().includes(partialName),
+ )
+ .map((target) => ({
+ id: `target:${target.id}`,
+ kind: "pattern",
+ label: target.displayLabel ?? target.label,
+ textClassName: target.textClassName,
+ detail: target.id === targetId ? "Current experiment scope" : undefined,
+ insert: `${serializeTarget(targetReference(target))}${fieldText}`,
+ requiresInput: indexOfOutsideQuotes(fieldText, ":") === -1,
+ replaceSpan: span,
+ }));
+ return {
+ ...(plan ?? {
+ stage: "field",
+ from: span.from,
+ to: span.to,
+ sections: [],
+ loading: false,
+ }),
+ sections: plan?.autoHighlight
+ ? [...plan.sections, { title: "Experiment", options }]
+ : [{ title: "Experiment", options }, ...(plan?.sections ?? [])],
+ autoHighlight: plan?.autoHighlight ?? false,
+ };
+}
+
/**
* The completion plan for the caret context, or null when nothing matches.
* The plan is a pure function of (text, caret, data) — never of HOW the
@@ -1297,7 +1562,7 @@ function scopeSwitchOptions(
* operator, after delete-to-empty) always plans the empty stage; a key
* position plans fields; a value position plans values.
*/
-export function planInputCompletions(
+function planUnscopedInputCompletions(
ctx: InputCompletionContext,
registry: FieldRegistry = EVENTS_FIELD_REGISTRY,
): CompletionPlan | null {
@@ -1356,7 +1621,7 @@ export function planInputCompletions(
// show a loading row while they stream in (lazy mode). Metadata keys are
// not server-enumerated — they come from the client-side observed-metadata
// map (lib/metadata-paths.ts) — so there is nothing to request there.
- if (path.kind.canonical !== "metadata.") {
+ if (path.kind.canonical !== "metadata." && !path.kind.metadataColumn) {
const scoreColumns =
path.kind.level === "trace"
? SCORE_COLUMNS.trace
@@ -1700,6 +1965,7 @@ export function applyPick(
// (value stage, next field, or an open `tags:(` group) — keep the popover
// open so the next pick is immediate.
keepOpen =
+ (option.kind === "pattern" && option.requiresInput === true) ||
option.insert.endsWith(":") ||
option.insert.endsWith(" ") ||
option.insert.endsWith("(");
@@ -1715,6 +1981,7 @@ export function applyPick(
// the filter (LFE-10501 BUG A). AND/NOT already carry a trailing space, so
// this only changes the value-stage comparison operators.
option.kind === "operator" ||
+ (option.kind === "pattern" && option.requiresInput === true) ||
insert.endsWith(":") ||
insert.endsWith(" ") ||
insert.endsWith("(");
diff --git a/web/src/features/search-bar/lib/composer-segments.ts b/web/src/features/search-bar/lib/composer-segments.ts
index a36d5efccc..3cb0a19f29 100644
--- a/web/src/features/search-bar/lib/composer-segments.ts
+++ b/web/src/features/search-bar/lib/composer-segments.ts
@@ -8,6 +8,7 @@
// from grammar semantics. Serialization stays separate and conservative
// (langQ.ts, edits.ts).
+import { resolveFilterTarget } from "./targeting";
import type { ScoreTypeContext } from "./adapter";
import type { ASTNode, CompareOp, FilterNode, Span, TextNode } from "./ast";
import { EVENTS_FIELD_REGISTRY, type FieldRegistry } from "./fields";
@@ -15,6 +16,7 @@ import { lexTokens, type Diagnostic } from "./langQ";
import { validateQuery } from "./validate";
export type FilterSegment = {
+ target?: { from: number; to: number; textClassName?: string };
id: string;
kind: "filter";
from: number;
@@ -164,8 +166,12 @@ export function deriveComposerSegments(
for (const leaf of leaves) leafByFrom.set(leaf.span.from, leaf);
const segments: ComposerSegment[] = [];
+ let consumedUntil = -1;
for (const token of lexTokens(draftText)) {
- const { span } = token;
+ if (token.span.from < consumedUntil) continue;
+ const matchedLeaf = leafByFrom.get(token.span.from);
+ const span = matchedLeaf?.kind === "filter" ? matchedLeaf.span : token.span;
+ consumedUntil = span.to;
const raw = draftText.slice(span.from, span.to);
const messages = overlappingErrors(diagnostics, span);
@@ -225,6 +231,22 @@ export function deriveComposerSegments(
valueOp: node.valueOp,
negated: leaf.negated,
editable: true,
+ ...(node.target?.span
+ ? {
+ target: {
+ from: node.target.span.from - span.from,
+ to: node.target.span.to - span.from,
+ textClassName: (() => {
+ const resolved = resolveFilterTarget(node, registry);
+ return "id" in resolved
+ ? registry.targeting?.targets.find(
+ (target) => target.id === resolved.id,
+ )?.textClassName
+ : undefined;
+ })(),
+ },
+ }
+ : {}),
});
continue;
}
diff --git a/web/src/features/search-bar/lib/fields.ts b/web/src/features/search-bar/lib/fields.ts
index 0d5008dfe3..a9bfc981c4 100644
--- a/web/src/features/search-bar/lib/fields.ts
+++ b/web/src/features/search-bar/lib/fields.ts
@@ -78,6 +78,21 @@ export type SearchScope = {
description: string;
};
+export type FilterTargeting = {
+ defaultTarget: string;
+ /** Meaning of targetless persisted filters, before target-aware editing. */
+ legacyDefaultTarget?: string;
+ targets: readonly {
+ id: string;
+ label: string;
+ displayLabel?: string;
+ keyword?: boolean;
+ textClassName?: string;
+ }[];
+ supports: (field: FieldRef) => boolean;
+ scoreTypesError?: string;
+};
+
export type FieldRegistry = {
id:
| "events"
@@ -106,9 +121,13 @@ export type FieldRegistry = {
fields: readonly FieldDef[];
columns: readonly ColumnDefinition[];
allowFreeText: boolean;
+ targeting?: FilterTargeting;
/** View-specific backend constraints beyond individual column operators. */
filterStateErrors?: (filters: FilterState) => readonly string[];
+ /** Whether this view exposes metadata.<key> filters. */
metadata: boolean;
+ /** Additional metadata roots mapped to their backend FilterState columns. */
+ metadataNamespaces?: Readonly<Record<string, string>>;
scores: boolean;
/** Trace-level `traceScores.<name>` paths. Views whose backend has no
* trace-score columns (sessions) keep observation scores without them. */
@@ -181,6 +200,7 @@ export function fieldRegistryFromColumns(
id: FieldRegistry["id"];
fields?: Readonly<Record<string, FieldOverlay>>;
metadata?: boolean;
+ metadataNamespaces?: Readonly<Record<string, string>>;
scores?: boolean;
/** Defaults to `scores`. */
traceScores?: boolean;
@@ -248,6 +268,7 @@ export function fieldRegistryFromColumns(
fields,
columns,
metadata: overlay.metadata ?? false,
+ metadataNamespaces: overlay.metadataNamespaces,
scores,
traceScores: overlay.traceScores ?? scores,
allowFreeText: overlay.allowFreeText ?? true,
@@ -279,12 +300,14 @@ export function extendFieldRegistryWithColumns(
fields: [...registry.fields, ...addedFields],
columns: [...registry.columns, ...columns],
metadata: registry.metadata,
+ metadataNamespaces: registry.metadataNamespaces,
scores: registry.scores,
traceScores: registry.traceScores,
allowFreeText: registry.allowFreeText,
defaultSearchType: registry.defaultSearchType,
searchScopes: registry.searchScopes,
filterStateErrors: registry.filterStateErrors,
+ targeting: registry.targeting,
defaultTextField: registry.defaultTextField,
freeTextScopeLabel: registry.freeTextScopeLabel,
searchExamples: registry.searchExamples,
@@ -325,12 +348,14 @@ export function withFieldOptions(
),
columns: registry.columns,
metadata: registry.metadata,
+ metadataNamespaces: registry.metadataNamespaces,
scores: registry.scores,
traceScores: registry.traceScores,
allowFreeText: registry.allowFreeText,
defaultSearchType: registry.defaultSearchType,
searchScopes: registry.searchScopes,
filterStateErrors: registry.filterStateErrors,
+ targeting: registry.targeting,
defaultTextField: registry.defaultTextField,
freeTextScopeLabel: registry.freeTextScopeLabel,
searchExamples: registry.searchExamples,
@@ -432,7 +457,7 @@ function isKeyedScoreColumn(column: string): boolean {
export type FieldRef =
| { type: "field"; field: FieldDef }
| { type: "searchScope"; id: string; scope: SearchScope }
- | { type: "metadata"; key: string }
+ | { type: "metadata"; key: string; namespace?: string; column?: string }
| { type: "scores"; key: string; level: "observation" | "trace" }
| { type: "pseudo"; id: typeof HAS_KEY | "in" };
@@ -449,12 +474,14 @@ export function createFieldRegistry({
fields,
columns,
metadata,
+ metadataNamespaces,
scores,
traceScores,
allowFreeText,
defaultSearchType = ["id", "content"],
searchScopes = {},
filterStateErrors,
+ targeting,
defaultTextField,
freeTextScopeLabel,
searchExamples,
@@ -467,11 +494,13 @@ export function createFieldRegistry({
fields: readonly FieldDef[];
columns: readonly ColumnDefinition[];
metadata: boolean;
+ metadataNamespaces?: Readonly<Record<string, string>>;
scores: boolean;
traceScores: boolean;
allowFreeText: boolean;
defaultSearchType?: readonly TracingSearchType[];
searchScopes?: Readonly<Record<string, SearchScope>>;
+ targeting?: FilterTargeting;
/** View-specific backend constraints beyond individual column operators. */
filterStateErrors?: (filters: FilterState) => readonly string[];
defaultTextField: string | null;
@@ -510,7 +539,9 @@ export function createFieldRegistry({
defaultSearchType,
searchScopes,
filterStateErrors,
+ targeting,
metadata,
+ metadataNamespaces,
scores,
traceScores,
defaultTextField,
@@ -527,6 +558,9 @@ export function createFieldRegistry({
const lower = value.toLowerCase();
return (
(metadata && lower === METADATA_PREFIX) ||
+ Object.keys(metadataNamespaces ?? {}).some(
+ (name) => lower === `${name.toLowerCase()}.`,
+ ) ||
(scores && SCORE_PREFIXES.includes(lower)) ||
(traceScores && TRACE_SCORE_PREFIXES.includes(lower))
);
@@ -612,6 +646,17 @@ function resolveFromRegistry(
byName: ReadonlyMap<string, FieldDef>,
): FieldRef | null {
const lower = name.toLowerCase();
+ for (const [namespace, column] of Object.entries(
+ registry.metadataNamespaces ?? {},
+ )) {
+ const prefix = `${namespace}.`;
+ if (lower.startsWith(prefix.toLowerCase())) {
+ const key = unquote(name.slice(prefix.length)).value;
+ return key.length > 0
+ ? { type: "metadata", key, namespace, column }
+ : null;
+ }
+ }
if (registry.metadata && lower.startsWith(METADATA_PREFIX)) {
const key = unquote(name.slice(METADATA_PREFIX.length)).value;
return key.length > 0 ? { type: "metadata", key } : null;
@@ -838,7 +883,7 @@ function refName(ref: FieldRef): string {
case "field":
return ref.field.id;
case "metadata":
- return `metadata.${quoteIfNeeded(ref.key)}`;
+ return `${ref.namespace ?? "metadata"}.${quoteIfNeeded(ref.key)}`;
case "scores":
return ref.level === "trace"
? `traceScores.${quoteIfNeeded(ref.key)}`
diff --git a/web/src/features/search-bar/lib/filter-state-to-query.ts b/web/src/features/search-bar/lib/filter-state-to-query.ts
index 8b78be21f1..2208a1ecdb 100644
--- a/web/src/features/search-bar/lib/filter-state-to-query.ts
+++ b/web/src/features/search-bar/lib/filter-state-to-query.ts
@@ -26,6 +26,7 @@ import {
} from "./fields";
import { serialize } from "./langQ";
import { quoteIfNeeded } from "./quoting";
+import { supportsFilterTarget, targetReference } from "./targeting";
function filterNode(
key: string,
@@ -202,10 +203,18 @@ function lowerSingle(
}
case "stringObject": {
const id = registry.columnIdOf(filter.column);
- if (id !== "metadata") return null;
+ const namespace =
+ Object.entries(registry.metadataNamespaces ?? {}).find(
+ ([, column]) => column === filter.column || column === id,
+ )?.[0] ?? (id === "metadata" && registry.metadata ? "metadata" : null);
+ if (namespace === null) return null;
// A key with grammar chars (`:`, space, …) is quoted so it re-lexes as one
// token (`metadata."my key"`); resolveField unquotes it on the way back.
- const key = `metadata.${quoteIfNeeded(filter.key)}`;
+ const key = `${namespace}.${quoteIfNeeded(filter.key)}`;
+ if (filter.operator === "is set" || filter.operator === "is not set") {
+ const presence = filterNode("has", "=", [key]);
+ return filter.operator === "is not set" ? negate(presence) : presence;
+ }
if (filter.operator === "does not contain") {
return negate(filterNode(key, "~", [filter.value]));
}
@@ -288,6 +297,33 @@ export function filterStateToQueryText(
skippedFilters.push(filter);
continue;
}
+ let condition: FilterNode | null = null;
+ if (node.kind === "filter") {
+ condition = node;
+ } else if (node.kind === "not" && node.child.kind === "filter") {
+ condition = node.child;
+ }
+ if (condition) {
+ if (registry.targeting && supportsFilterTarget(condition, registry)) {
+ const target = registry.targeting.targets.find(
+ (entry) =>
+ entry.id ===
+ (filter.target ??
+ registry.targeting?.legacyDefaultTarget ??
+ registry.targeting?.defaultTarget),
+ );
+ if (!target) {
+ skipped.push(`${filter.column} (target unavailable)`);
+ skippedFilters.push(filter);
+ continue;
+ }
+ condition.target = targetReference(target);
+ } else if (filter.target) {
+ skipped.push(`${filter.column} (target not supported)`);
+ skippedFilters.push(filter);
+ continue;
+ }
+ }
nodes.push(node);
}
diff --git a/web/src/features/search-bar/lib/langQ.ts b/web/src/features/search-bar/lib/langQ.ts
index 91ce5b7250..d18c9c0df4 100644
--- a/web/src/features/search-bar/lib/langQ.ts
+++ b/web/src/features/search-bar/lib/langQ.ts
@@ -7,7 +7,8 @@
// orExpr := andExpr (OR andExpr)*
// andExpr := unary ((AND)? unary)* -- implicit AND on adjacency
// unary := NOT unary | '-'term | '(' expr ')' | term
-// term := key ':' valueExpr | freeText
+// term := (target '.')? key ':' valueExpr | freeText
+// target := quotedName | hostKeyword -- registry capability only
// valueExpr := ('>'|'<'|'>='|'<=') scalar | '=' scalar | globValue | '(' value (OR value)* ')'
// globValue := value with optional leading/trailing '*' wildcards:
// 'v*' starts-with, '*v' ends-with, '*v*' contains, 'v' default
@@ -18,6 +19,7 @@
// Langfuse filter contract can represent (e.g. cross-field OR) — those forms
// are rejected with targeted messages in validate.ts, not here.
+import { readTargetPrefix, serializeTarget } from "./targeting";
import type { ASTNode, CompareOp, FilterNode, Span, TextNode } from "./ast";
import {
canonicalKey,
@@ -266,6 +268,48 @@ function parseTermNode(
span: Span,
diagnostics: Diagnostic[],
registry: FieldRegistry,
+): FilterNode | TextNode {
+ const prefix = readTargetPrefix(raw, registry);
+ if (!prefix) return parseUnscopedTermNode(raw, span, diagnostics, registry);
+ const fieldRaw = raw.slice(prefix.length);
+ const fieldSpan = { from: span.from + prefix.length, to: span.to };
+ const node = parseUnscopedTermNode(
+ fieldRaw,
+ fieldSpan,
+ diagnostics,
+ registry,
+ );
+ if (node.kind !== "filter") {
+ diagnostics.push({
+ ...span,
+ severity: "error",
+ message: "Incomplete targeted filter — choose a field and value",
+ });
+ return {
+ kind: "filter",
+ key: fieldRaw,
+ rawKey: fieldRaw,
+ values: [],
+ op: "=",
+ target: {
+ ...prefix.target,
+ span: { from: span.from, to: fieldSpan.from },
+ },
+ span,
+ };
+ }
+ return {
+ ...node,
+ target: { ...prefix.target, span: { from: span.from, to: fieldSpan.from } },
+ span,
+ };
+}
+
+function parseUnscopedTermNode(
+ raw: string,
+ span: Span,
+ diagnostics: Diagnostic[],
+ registry: FieldRegistry,
): FilterNode | TextNode {
const reserved = reservedTokenIssue(raw);
if (reserved !== null) {
@@ -653,6 +697,45 @@ export function parse(
}
}
const node = parseUnary();
+ const suffix = peek();
+ if (
+ registry.targeting &&
+ suffix?.type === "term" &&
+ suffix.raw.startsWith("@")
+ ) {
+ let filter: FilterNode | null = null;
+ if (node?.kind === "filter") {
+ filter = node;
+ } else if (node?.kind === "not" && node.child.kind === "filter") {
+ filter = node.child;
+ }
+
+ if (filter && !node?.parenSpan && !filter.parenSpan) {
+ next();
+ if (filter.target) {
+ diagnostics.push({
+ ...suffix.span,
+ severity: "error",
+ message: "A filter can only have one experiment target",
+ });
+ }
+ const raw = suffix.raw.slice(1);
+ const decoded = unquote(raw);
+ filter.target = {
+ kind: decoded.quoted ? "name" : "keyword",
+ value: decoded.value,
+ span: suffix.span,
+ };
+ if (!decoded.value)
+ diagnostics.push({
+ ...suffix.span,
+ severity: "error",
+ message: "Missing target after @",
+ });
+ if (filter.span) filter.span.to = suffix.span.to;
+ if (node?.kind === "not" && node.span) node.span.to = suffix.span.to;
+ }
+ }
if (node !== null) children.push(node);
}
if (children.length === 0) return null;
@@ -880,6 +963,11 @@ const OP_SYMBOL: Partial<Record<CompareOp, string>> = {
};
function serializeFilter(node: FilterNode): string {
+ const text = serializeBareFilter(node);
+ return node.target ? `${serializeTarget(node.target)}${text}` : text;
+}
+
+function serializeBareFilter(node: FilterNode): string {
// Prefer the user's typed key (alias/casing) — surgery fallbacks shouldn't
// canonicalize untouched filters.
const key = node.rawKey ?? node.key;
@@ -907,7 +995,7 @@ function serializeFilter(node: FilterNode): string {
function sameFieldOrGroup(node: ASTNode): FilterNode[] | null {
if (node.kind !== "or") return null;
const filters = node.children.filter(
- (c): c is FilterNode => c.kind === "filter",
+ (c): c is FilterNode => c.kind === "filter" && !c.target,
);
if (filters.length !== node.children.length || filters.length < 2)
return null;
diff --git a/web/src/features/search-bar/lib/targeting.ts b/web/src/features/search-bar/lib/targeting.ts
new file mode 100644
index 0000000000..7b7e624bd3
--- /dev/null
+++ b/web/src/features/search-bar/lib/targeting.ts
@@ -0,0 +1,140 @@
+import type { FilterNode } from "./ast";
+import type { FieldRegistry, FilterTargeting } from "./fields";
+import { quote, quoteIfNeeded, unquote } from "./quoting";
+
+/** The target is separate from the field path, including during partial input. */
+export function readTargetPrefix(
+ raw: string,
+ registry: FieldRegistry,
+): {
+ target: NonNullable<FilterNode["target"]>;
+ length: number;
+ incomplete: boolean;
+} | null {
+ if (!registry.targeting) return null;
+ if (raw.startsWith('"')) {
+ let end = 1;
+ for (; end < raw.length; end++) {
+ if (raw[end] === "\\") {
+ end++;
+ continue;
+ }
+ if (raw[end] === '"') break;
+ }
+ if (end >= raw.length || end === raw.length - 1) {
+ return {
+ target: {
+ kind: "name",
+ value: unquote(end >= raw.length ? `${raw}"` : raw).value,
+ },
+ length: raw.length,
+ incomplete: true,
+ };
+ }
+ if (raw[end + 1] !== ".") return null;
+ const value = unquote(raw.slice(0, end + 1)).value;
+ const keyword = registry.targeting.targets.find(
+ (target) =>
+ target.keyword && /\s/.test(target.label) && target.label === value,
+ );
+ return {
+ target: keyword ? targetReference(keyword) : { kind: "name", value },
+ length: end + 2,
+ incomplete: false,
+ };
+ }
+ for (const target of registry.targeting.targets) {
+ if (!target.keyword) continue;
+ // Accept the stable keyword ID as an alias for existing saved searches.
+ const prefix = [target.label, target.id]
+ .map((label) => `${label}.`)
+ .find((prefix) => raw.toLowerCase().startsWith(prefix.toLowerCase()));
+ if (prefix) {
+ return {
+ target:
+ prefix === `${target.id}.` && target.label !== target.id
+ ? { kind: "keyword", value: target.id }
+ : targetReference(target),
+ length: prefix.length,
+ incomplete: false,
+ };
+ }
+ }
+ return null;
+}
+
+export function resolveFilterTarget(
+ node: FilterNode,
+ registry: FieldRegistry,
+): { id: string } | { error: string } {
+ const capability = registry.targeting;
+ if (!capability || !supportsFilterTarget(node, registry)) {
+ return { error: "This filter does not support a target" };
+ }
+ const ref = node.target;
+ const matches = capability.targets.filter((target) => {
+ if (!ref) return target.id === capability.defaultTarget;
+ if (ref.kind === "keyword")
+ return (
+ target.keyword &&
+ (target.label === ref.value || target.id === ref.value)
+ );
+ return !target.keyword && target.label === ref.value;
+ });
+ if (matches.length !== 1) {
+ return {
+ error:
+ matches.length > 1
+ ? "Target name is ambiguous; select a specific target"
+ : "Target is unavailable; select an available target",
+ };
+ }
+ return { id: matches[0].id };
+}
+
+/** Presence predicates inherit the capability of the fields they inspect. */
+export function supportsFilterTarget(
+ node: FilterNode,
+ registry: FieldRegistry,
+): boolean {
+ const capability = registry.targeting;
+ if (!capability) return false;
+ const field = registry.resolveField(node.key);
+ if (field?.type === "pseudo" && field.id === "has") {
+ return (
+ node.values.length > 0 &&
+ node.values.every((value) => {
+ const referenced = registry.resolveField(value);
+ return referenced !== null && capability.supports(referenced);
+ })
+ );
+ }
+ return field !== null && capability.supports(field);
+}
+
+/**
+ * Resolve the registry target this filter binds to, or undefined when the
+ * field is not targetable and the node carries no explicit target.
+ */
+export function resolveAttachedTarget(
+ node: FilterNode,
+ registry: FieldRegistry,
+): { id: string } | { error: string } | undefined {
+ if (!node.target && !supportsFilterTarget(node, registry)) {
+ return undefined;
+ }
+ return resolveFilterTarget(node, registry);
+}
+
+export function targetReference(
+ target: FilterTargeting["targets"][number],
+): NonNullable<FilterNode["target"]> {
+ return { kind: target.keyword ? "keyword" : "name", value: target.label };
+}
+
+export function serializeTarget(
+ target: NonNullable<FilterNode["target"]>,
+): string {
+ if (target.kind === "keyword") return `${quoteIfNeeded(target.value)}.`;
+ return `${quote(target.value)}.`;
+}