🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
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.mdindex 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, andthree items, then prints the experiment results link. Add `--compare` for adiff --git a/packages/shared/scripts/seeder/AGENTS.md b/packages/shared/scripts/seeder/AGENTS.mdindex 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 Topnpm run seed -- topics --batch evaluation --id-prefix topics-eval-s42 # 100 diverse requests, tool failures and successful outcomespnpm 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 modelpnpm 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 resultspnpm run seed -- experiment-io --compare # same dataset plus a second run with a long chat output, for the comparison tableNEXTAUTH_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.mdindex 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 istwo `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).+## TopicsAfter 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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 itdiff --git a/packages/shared/src/interfaces/filters.ts b/packages/shared/src/interfaces/filters.tsindex 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/tRPCdiff --git a/packages/shared/src/server/queries/clickhouse-sql/query-fragments.ts b/packages/shared/src/server/queries/clickhouse-sql/query-fragments.tsindex 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.tsxindex 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"]}><spanclassName={cn(diff --git a/web/src/components/ui/popover.tsx b/web/src/components/ui/popover.tsxindex 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 = ({<PopoverContentalign={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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.mdnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsxdeleted file mode 100644index 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.tsxindex 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}preferNegativeDiffformatValue={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}preferNegativeDiffformatValue={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.tsxindex 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 filtersconst 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 && (<RunEvaluationDialogprojectId={projectId}selectedObservationIds={selectedObservationIds}diff --git a/web/src/features/experiments/constants/experimentItemsSearchRegistry.clienttest.ts b/web/src/features/experiments/constants/experimentItemsSearchRegistry.clienttest.tsindex 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.tsindex 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.tsindex 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 columnsconst 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.tsnew file mode 100644index 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.tsindex 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 payloadsconst 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsdeleted file mode 100644index 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.tsdeleted file mode 100644index 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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.8export 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 contextlet 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.mdindex 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 cannotrepresent are commit-blocking diagnostics, not silent drops. There is noFTS `*` 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.tsxindex 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.tsxindex 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.tsxindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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)}.`;+}