@growthbook/mcp 1.4.4 → 1.5.0

package/server/tools/experiments/experiments.js

@@ -1,24 +1,76 @@
 import { z } from "zod";
-import { generateLinkToGrowthBook, getDocsMetadata, handleResNotOk, SUPPORTED_FILE_EXTENSIONS, paginationSchema, fetchWithRateLimit, } from "../../utils.js";
+import { generateLinkToGrowthBook, getDocsMetadata, handleResNotOk, SUPPORTED_FILE_EXTENSIONS, paginationSchema, fetchWithRateLimit, fetchWithPagination, featureFlagSchema, fetchFeatureFlag, mergeRuleIntoFeatureFlag, } from "../../utils.js";
 import { getDefaults } from "../defaults.js";
 import { handleSummaryMode } from "./experiment-summary.js";
 export function registerExperimentTools({ server, baseApiUrl, apiKey, appOrigin, user, }) {
     /**
      * Tool: get_experiments
      */
-    server.tool("get_experiments", "Fetches experiments from the GrowthBook API", {
-        project: z
-            .string()
-            .describe("The ID of the project to filter experiments by")
-            .optional(),
-        mode: z
-            .enum(["metadata", "summary", "full"])
-            .default("metadata")
-            .describe("The mode to use to fetch experiments. Metadata mode returns experiment config without results. Summary mode fetches results and returns pruned key stats for quick analysis. Full mode fetches and returns complete results data. WARNING: Full mode may return large payloads."),
-        ...paginationSchema,
-    }, {
-        readOnlyHint: true,
-    }, async ({ limit, offset, mostRecent, project, mode }, extra) => {
+    server.registerTool("get_experiments", {
+        title: "Get Experiments",
+        description: "Lists experiments or fetches details for a specific experiment. Supports three modes: metadata (default) returns experiment config without results, good for listing; summary fetches results and returns key statistics including win rate and top performers, good for quick analysis; full returns complete results with all metrics (warning: large payloads). Use this to review recent experiments (mostRecent=true), analyze results, or check experiment status (draft, running, stopped). Single experiment fetch includes a link to view in GrowthBook.",
+        inputSchema: z.object({
+            project: z
+                .string()
+                .describe("The ID of the project to filter experiments by")
+                .optional(),
+            mode: z
+                .enum(["metadata", "summary", "full"])
+                .default("metadata")
+                .describe("The mode to use to fetch experiments. Metadata mode returns experiment config without results. Summary mode fetches results and returns pruned key stats for quick analysis. Full mode fetches and returns complete results data. WARNING: Full mode may return large payloads."),
+            experimentId: z
+                .string()
+                .describe("The ID of the experiment to fetch")
+                .optional(),
+            ...paginationSchema,
+        }),
+        annotations: {
+            readOnlyHint: true,
+        },
+    }, async ({ limit, offset, mostRecent, project, mode, experimentId }, extra) => {
+        if (experimentId) {
+            try {
+                const res = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experimentId}`, {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        "Content-Type": "application/json",
+                    },
+                });
+                await handleResNotOk(res);
+                const data = await res.json();
+                // Fetch results
+                if (mode === "full") {
+                    if (data.status === "draft") {
+                        data.result = null;
+                    }
+                    try {
+                        const resultsRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experimentId}/results`, {
+                            headers: {
+                                Authorization: `Bearer ${apiKey}`,
+                            },
+                        });
+                        await handleResNotOk(resultsRes);
+                        const resultsData = await resultsRes.json();
+                        data.result = resultsData.result;
+                    }
+                    catch (error) {
+                        console.error(`Error fetching results for experiment ${experimentId}`, error);
+                    }
+                }
+                const linkToGrowthBook = generateLinkToGrowthBook(appOrigin, "experiment", experimentId);
+                const text = `
+      ${JSON.stringify(data)}
+      
+      [View the experiment in GrowthBook](${linkToGrowthBook})
+      `;
+                return {
+                    content: [{ type: "text", text }],
+                };
+            }
+            catch (error) {
+                throw new Error(`Error getting experiment: ${error}`);
+            }
+        }
         const progressToken = extra._meta?.progressToken;
         const totalSteps = mode === "summary" ? 5 : mode === "full" ? 3 : 2;
         const reportProgress = async (progress, message) => {
@@ -36,128 +88,44 @@ export function registerExperimentTools({ server, baseApiUrl, apiKey, appOrigin,
         };
         await reportProgress(1, "Fetching experiments...");
         try {
-            // Default behavior
-            if (!mostRecent || offset > 0) {
-                const defaultQueryParams = new URLSearchParams({
-                    limit: limit.toString(),
-                    offset: offset.toString(),
-                });
-                if (project) {
-                    defaultQueryParams.append("projectId", project);
-                }
-                const defaultRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments?${defaultQueryParams.toString()}`, {
-                    headers: {
-                        Authorization: `Bearer ${apiKey}`,
-                        "Content-Type": "application/json",
-                    },
-                });
-                await handleResNotOk(defaultRes);
-                const data = await defaultRes.json();
-                const experiments = data.experiments;
-                if (mode === "full" || mode === "summary") {
-                    await reportProgress(2, "Fetching experiment results...");
-                    for (const [index, experiment] of experiments.entries()) {
-                        if (experiment.status === "draft") {
-                            experiments[index].result = undefined;
-                            continue;
-                        }
-                        try {
-                            const resultsRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experiment.id}/results`, {
-                                headers: {
-                                    Authorization: `Bearer ${apiKey}`,
-                                },
-                            });
-                            await handleResNotOk(resultsRes);
-                            const resultsData = await resultsRes.json();
-                            experiments[index].result = resultsData.result;
-                        }
-                        catch (error) {
-                            console.error(`Error fetching results for experiment ${experiment.id} (${experiment.name})`, error);
-                        }
+            const data = await fetchWithPagination(baseApiUrl, apiKey, "/api/v1/experiments", limit, offset, mostRecent, project ? { projectId: project } : undefined);
+            let experiments = data.experiments || [];
+            // Reverse experiments array for mostRecent to show newest-first
+            if (mostRecent && offset === 0 && Array.isArray(experiments)) {
+                experiments = experiments.reverse();
+                data.experiments = experiments;
+            }
+            if (mode === "full" || mode === "summary") {
+                await reportProgress(2, "Fetching experiment results...");
+                for (const [index, experiment] of experiments.entries()) {
+                    if (experiment.status === "draft") {
+                        experiments[index].result = undefined;
+                        continue;
                     }
-                }
-                if (mode === "summary") {
-                    const summaryExperiments = await handleSummaryMode(experiments, baseApiUrl, apiKey, reportProgress);
-                    const summaryExperimentsWithPagination = {
-                        summary: summaryExperiments,
-                        limit: data.limit,
-                        offset: data.offset,
-                        total: data.total,
-                        hasMore: data.hasMore,
-                        nextOffset: data.nextOffset,
-                    };
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify(summaryExperimentsWithPagination),
+                    try {
+                        const resultsRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experiment.id}/results`, {
+                            headers: {
+                                Authorization: `Bearer ${apiKey}`,
                             },
-                        ],
-                    };
-                }
-                await reportProgress(2, "Processing results...");
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data) }],
-                };
-            }
-            // Most recent behavior
-            const countRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments?limit=1`, {
-                headers: {
-                    Authorization: `Bearer ${apiKey}`,
-                },
-            });
-            await handleResNotOk(countRes);
-            const countData = await countRes.json();
-            const total = countData.total;
-            const calculatedOffset = Math.max(0, total - limit);
-            const mostRecentQueryParams = new URLSearchParams({
-                limit: limit.toString(),
-                offset: calculatedOffset.toString(),
-            });
-            if (project) {
-                mostRecentQueryParams.append("projectId", project);
-            }
-            const mostRecentRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments?${mostRecentQueryParams.toString()}`, {
-                headers: {
-                    Authorization: `Bearer ${apiKey}`,
-                },
-            });
-            await handleResNotOk(mostRecentRes);
-            const mostRecentData = await mostRecentRes.json();
-            if (mostRecentData.experiments &&
-                Array.isArray(mostRecentData.experiments)) {
-                mostRecentData.experiments = mostRecentData.experiments.reverse();
-                if (mode === "full" || mode === "summary") {
-                    await reportProgress(2, "Fetching experiment results...");
-                    for (const [index, experiment,] of mostRecentData.experiments.entries()) {
-                        try {
-                            const resultsRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experiment.id}/results`, {
-                                headers: {
-                                    Authorization: `Bearer ${apiKey}`,
-                                },
-                            });
-                            await handleResNotOk(resultsRes);
-                            const resultsData = await resultsRes.json();
-                            mostRecentData.experiments[index].result = resultsData.result;
-                        }
-                        catch (error) {
-                            console.error(`Error fetching results for experiment ${experiment.id} (${experiment.name})`, error);
-                        }
+                        });
+                        await handleResNotOk(resultsRes);
+                        const resultsData = await resultsRes.json();
+                        experiments[index].result = resultsData.result;
+                    }
+                    catch (error) {
+                        console.error(`Error fetching results for experiment ${experiment.id} (${experiment.name})`, error);
                     }
                 }
             }
             if (mode === "summary") {
-                const experiments = Array.isArray(mostRecentData.experiments)
-                    ? mostRecentData.experiments
-                    : [];
                 const summaryExperiments = await handleSummaryMode(experiments, baseApiUrl, apiKey, reportProgress);
                 const summaryExperimentsWithPagination = {
                     summary: summaryExperiments,
-                    limit: mostRecentData.limit,
-                    offset: mostRecentData.offset,
-                    total: mostRecentData.total,
-                    hasMore: mostRecentData.hasMore,
-                    nextOffset: mostRecentData.nextOffset,
+                    limit: data.limit,
+                    offset: data.offset,
+                    total: data.total,
+                    hasMore: data.hasMore,
+                    nextOffset: data.nextOffset,
                 };
                 return {
                     content: [
@@ -168,73 +136,25 @@ export function registerExperimentTools({ server, baseApiUrl, apiKey, appOrigin,
                     ],
                 };
             }
+            await reportProgress(2, "Processing results...");
             return {
-                content: [{ type: "text", text: JSON.stringify(mostRecentData) }],
+                content: [{ type: "text", text: JSON.stringify(data) }],
             };
         }
         catch (error) {
             throw new Error(`Error fetching experiments: ${error}`);
         }
     });
-    /**
-     * Tool: get_experiment
-     */
-    server.tool("get_experiment", "Gets a single experiment from GrowthBook", {
-        experimentId: z.string().describe("The ID of the experiment to get"),
-        mode: z
-            .enum(["metadata", "full"])
-            .default("metadata")
-            .describe("The mode to use to fetch the experiment. Metadata mode returns summary info about the experiment. Full mode fetches results and returns complete results data."),
-    }, {
-        readOnlyHint: true,
-    }, async ({ experimentId, mode }) => {
-        try {
-            const res = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experimentId}`, {
-                headers: {
-                    Authorization: `Bearer ${apiKey}`,
-                    "Content-Type": "application/json",
-                },
-            });
-            await handleResNotOk(res);
-            const data = await res.json();
-            // If analyze or summary mode, fetch results
-            if (mode === "full") {
-                if (data.status === "draft") {
-                    data.result = null;
-                }
-                try {
-                    const resultsRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/experiments/${experimentId}/results`, {
-                        headers: {
-                            Authorization: `Bearer ${apiKey}`,
-                        },
-                    });
-                    await handleResNotOk(resultsRes);
-                    const resultsData = await resultsRes.json();
-                    data.result = resultsData.result;
-                }
-                catch (error) {
-                    console.error(`Error fetching results for experiment ${experimentId}`, error);
-                }
-            }
-            const linkToGrowthBook = generateLinkToGrowthBook(appOrigin, "experiment", experimentId);
-            const text = `
-    ${JSON.stringify(data)}
-    
-    [View the experiment in GrowthBook](${linkToGrowthBook})
-    `;
-            return {
-                content: [{ type: "text", text }],
-            };
-        }
-        catch (error) {
-            throw new Error(`Error getting experiment: ${error}`);
-        }
-    });
     /**
      * Tool: get_attributes
      */
-    server.tool("get_attributes", "Get all attributes", {}, {
-        readOnlyHint: true,
+    server.registerTool("get_attributes", {
+        title: "Get Attributes",
+        description: "Lists all user attributes configured in GrowthBook. Attributes are user properties (like country, plan type, user ID) used for targeting in feature flags and experiments. Use this to see available attributes for targeting conditions in create_force_rule, understand targeting options when setting up experiments, or verify attribute names before writing conditions. Common examples: id, email, country, plan, deviceType, isEmployee. Attributes must be passed to the GrowthBook SDK at runtime for targeting to work.",
+        inputSchema: z.object({}),
+        annotations: {
+            readOnlyHint: true,
+        },
     }, async () => {
         try {
             const queryParams = new URLSearchParams();
@@ -258,44 +178,55 @@ export function registerExperimentTools({ server, baseApiUrl, apiKey, appOrigin,
     /**
      * Tool: create_experiment
      */
-    server.tool("create_experiment", "IMPORTANT: Call get_defaults before creating an experiment, and use its output to guide the arguments. Creates a new feature flag and experiment (A/B test).", {
-        name: z
-            .string()
-            .describe("Experiment name. Base name off the examples from get_defaults. If none are available, use a short, descriptive name that captures the essence of the experiment."),
-        description: z.string().optional().describe("Experiment description."),
-        hypothesis: z
-            .string()
-            .optional()
-            .describe("Experiment hypothesis. Base hypothesis off the examples from get_defaults. If none are available, use a falsifiable statement about what will happen if the experiment succeeds or fails."),
-        variations: z
-            .array(z.object({
+    server.registerTool("create_experiment", {
+        title: "Create Experiment",
+        description: "Creates a new A/B test experiment in GrowthBook. An experiment randomly assigns users to different variations and measures which performs better against your metrics. Prerequisites: 1) Call get_defaults first to review naming conventions and configuration, 2) If testing via a feature flag, provide its featureId OR create the flag first using create_feature_flag. Returns a draft experiment that the user must review and launch in the GrowthBook UI, including a link and SDK integration code. Do NOT use for simple feature toggles (use create_feature_flag) or targeting without measurement (use create_force_rule).",
+        inputSchema: z.object({
             name: z
                 .string()
-                .describe("Variation name. Base name off the examples from get_defaults. If none are available, use a short, descriptive name that captures the essence of the variation."),
-            value: z
-                .union([
-                z.string(),
-                z.number(),
-                z.boolean(),
-                z.record(z.string(), z.any()),
-            ])
-                .describe("The value of the control and each of the variations. The value should be a string, number, boolean, or object. If it's an object, it should be a valid JSON object."),
-        }))
-            .describe("Experiment variations. The key should be the variation name and the value should be the variation value. Look to variations included in preview experiments for guidance on generation. The default or control variation should always be first."),
-        project: z
-            .string()
-            .describe("The ID of the project to create the experiment in")
-            .optional(),
-        fileExtension: z
-            .enum(SUPPORTED_FILE_EXTENSIONS)
-            .describe("The extension of the current file. If it's unclear, ask the user."),
-        confirmedDefaultsReviewed: z
-            .boolean()
-            .describe("Set to true to confirm you have called get_defaults and reviewed the output to guide these parameters."),
-    }, {
-        readOnlyHint: false,
-        destructiveHint: false,
-    }, async ({ description, hypothesis, name, variations, fileExtension, confirmedDefaultsReviewed, project, }) => {
+                .describe("Experiment name. Base name off the examples from get_defaults. If none are available, use a short, descriptive name that captures the essence of the experiment."),
+            description: z.string().optional().describe("Experiment description."),
+            hypothesis: z
+                .string()
+                .optional()
+                .describe("Experiment hypothesis. Base hypothesis off the examples from get_defaults. If none are available, use a falsifiable statement about what will happen if the experiment succeeds or fails."),
+            valueType: z
+                .enum(["string", "number", "boolean", "json"])
+                .describe("The value type for all experiment variations"),
+            variations: z
+                .array(z.object({
+                name: z
+                    .string()
+                    .describe("Variation name. Base name off the examples from get_defaults. If none are available, use a short, descriptive name that captures the essence of the variation."),
+                value: z
+                    .union([
+                    z.string(),
+                    z.number(),
+                    z.boolean(),
+                    z.record(z.string(), z.any()),
+                ])
+                    .describe("The value of this variation. Must match the specified valueType: provide actual booleans (true/false) not strings, actual numbers, strings, or valid JSON objects."),
+            }))
+                .describe('Array of experiment variations. Each has a name (displayed in GrowthBook UI) and value (what users receive). The first variation should be the control/default. Example: [{name: "Control", value: false}, {name: "Treatment", value: true}]'),
+            project: z
+                .string()
+                .describe("The ID of the project to create the experiment in")
+                .optional(),
+            featureId: featureFlagSchema.id
+                .optional()
+                .describe("The ID of the feature flag to create the experiment on."),
+            fileExtension: z
+                .enum(SUPPORTED_FILE_EXTENSIONS)
+                .describe("The extension of the current file. If it's unclear, ask the user."),
+            confirmedDefaultsReviewed: z
+                .boolean()
+                .describe("Set to true to confirm you have called get_defaults and reviewed the output to guide these parameters."),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+        },
+    }, async ({ description, hypothesis, name, valueType, variations, fileExtension, confirmedDefaultsReviewed, project, featureId, }) => {
         if (!confirmedDefaultsReviewed) {
             return {
                 content: [
@@ -335,65 +266,42 @@ export function registerExperimentTools({ server, baseApiUrl, apiKey, appOrigin,
             });
             await handleResNotOk(experimentRes);
             const experimentData = await experimentRes.json();
-            const flagId = `flag_${name.toLowerCase().replace(/[^a-z0-9]/g, "_")}`;
-            const flagPayload = {
-                id: flagId,
-                owner: user,
-                defaultValue: stringifyValue(variations[0].value),
-                valueType: typeof variations[0].value === "string"
-                    ? "string"
-                    : typeof variations[0].value === "number"
-                        ? "number"
-                        : typeof variations[0].value === "boolean"
-                            ? "boolean"
-                            : "json",
-                description,
-                environments: {
-                    ...experimentDefaults.environments.reduce((acc, env) => {
-                        acc[env] = {
-                            enabled: false,
-                            rules: [
-                                {
-                                    type: "experiment-ref",
-                                    experimentId: experimentData.experiment.id,
-                                    variations: experimentData.experiment.variations.map((expVariation, idx) => ({
-                                        value: stringifyValue(variations[idx].value),
-                                        variationId: expVariation.variationId,
-                                    })),
-                                },
-                            ],
-                        };
-                        return acc;
-                    }, {}),
-                },
-            };
-            const flagRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/features`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify(flagPayload),
-            });
-            await handleResNotOk(flagRes);
-            const flagData = await flagRes.json();
+            let flagData = null;
+            if (featureId) {
+                // Fetch the existing feature flag first to preserve existing rules
+                const existingFeature = await fetchFeatureFlag(baseApiUrl, apiKey, featureId);
+                // Create new experiment-ref rule
+                const newRule = {
+                    type: "experiment-ref",
+                    experimentId: experimentData.experiment.id,
+                    variations: experimentData.experiment.variations.map((expVariation, idx) => ({
+                        value: stringifyValue(variations[idx].value),
+                        variationId: expVariation.variationId,
+                    })),
+                };
+                // Merge new rule into existing feature flag
+                const flagPayload = mergeRuleIntoFeatureFlag(existingFeature, newRule, experimentDefaults.environments);
+                const flagRes = await fetchWithRateLimit(`${baseApiUrl}/api/v1/features/${featureId}`, {
+                    method: "POST",
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify(flagPayload),
+                });
+                await handleResNotOk(flagRes);
+                flagData = await flagRes.json();
+            }
             const experimentLink = generateLinkToGrowthBook(appOrigin, "experiment", experimentData.experiment.id);
-            const flagLink = generateLinkToGrowthBook(appOrigin, "features", flagData.feature.id);
             const { stub, docs, language } = getDocsMetadata(fileExtension);
-            const text = `
-(To the LLM. It's essential to show the links below to the user. This is the only way they can review and launch the experiment.)
-**✅ Your draft experiment \`${name}\` is ready!.** [View the experiment in GrowthBook](${experimentLink}) to review and launch.
-
-A linked feature flag was also created: \`${flagId}\`. [View the feature flag in GrowthBook](${flagLink}).
-
-**How to use it in your code:**
-(To the LLM agent. GrowthBook uses feature flags to implement experiments. Use the code snippets below to properly update the file to use the new feature flag)
-
+            const flagText = featureId &&
+                `**How to implement the feature flag experiment in your code:**
+---
 ${stub}
-
+---
 **Learn more about implementing experiments in your codebase:**
-See the [GrowthBook ${language} docs](${docs})
-    `;
+See the [GrowthBook ${language} docs](${docs}).`;
+            const text = `**✅ Your draft experiment \`${name}\` is ready!.** [View the experiment in GrowthBook](${experimentLink}) to review and launch.\n\n${flagText}`;
             return {
                 content: [{ type: "text", text }],
             };

package/server/tools/experiments/summary-logic.js

@@ -0,0 +1,134 @@
+export function median(arr) {
+    if (arr.length === 0)
+        return null;
+    const sorted = [...arr].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+export function round(n, decimals = 4) {
+    if (n === null || n === undefined || isNaN(n))
+        return null;
+    return Math.round(n * 10 ** decimals) / 10 ** decimals;
+}
+export function formatLift(lift) {
+    if (lift === null)
+        return "N/A";
+    const sign = lift >= 0 ? "+" : "";
+    return `${sign}${(lift * 100).toFixed(1)}%`;
+}
+export function getYearMonth(dateStr) {
+    if (!dateStr)
+        return null;
+    const d = new Date(dateStr);
+    if (isNaN(d.getTime()))
+        return null;
+    return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+}
+export function computePrimaryMetricResult(resultData, metricLookup, goalIds) {
+    const primaryMetricId = goalIds[0];
+    if (!primaryMetricId)
+        return null;
+    const primaryMetricData = resultData.metrics?.find((m) => m.metricId === primaryMetricId);
+    if (!primaryMetricData || primaryMetricData.variations.length <= 1) {
+        return null;
+    }
+    const metricInfo = metricLookup.get(primaryMetricId);
+    const isInverse = metricInfo?.inverse ?? false;
+    // Find best performing variation (excluding control at index 0)
+    let bestVariation = primaryMetricData.variations[1];
+    let bestLift = bestVariation?.analyses?.[0]?.percentChange ?? 0;
+    for (let i = 2; i < primaryMetricData.variations.length; i++) {
+        const v = primaryMetricData.variations[i];
+        const lift = v.analyses?.[0]?.percentChange ?? 0;
+        const isBetter = isInverse ? lift < bestLift : lift > bestLift;
+        if (isBetter) {
+            bestVariation = v;
+            bestLift = lift;
+        }
+    }
+    const analysis = bestVariation?.analyses?.[0];
+    if (!analysis)
+        return null;
+    const lift = analysis.percentChange;
+    const chanceToBeatControl = analysis.chanceToBeatControl;
+    let significant = false;
+    if (chanceToBeatControl !== undefined) {
+        significant = chanceToBeatControl > 0.95 || chanceToBeatControl < 0.05;
+    }
+    else {
+        significant =
+            analysis.ciLow !== undefined &&
+                analysis.ciHigh !== undefined &&
+                (analysis.ciLow > 0 || analysis.ciHigh < 0);
+    }
+    let direction = "flat";
+    if (significant) {
+        const rawPositive = lift > 0;
+        const isWinning = isInverse ? !rawPositive : rawPositive;
+        direction = isWinning ? "winning" : "losing";
+    }
+    return {
+        id: primaryMetricId,
+        name: metricInfo?.name || primaryMetricId,
+        lift: round(lift),
+        significant,
+        direction,
+    };
+}
+export function computeVerdict(exp, metricLookup) {
+    const resultData = exp.result?.results?.[0];
+    const srmPValue = resultData?.checks?.srm ?? null;
+    const totalUsers = resultData?.totalUsers || 0;
+    const srmPassing = srmPValue !== null ? srmPValue > 0.001 : true;
+    // Get goal and guardrail metric IDs
+    const goalIds = exp.settings?.goals?.map((g) => g.metricId) || [];
+    const guardrailIds = new Set(exp.settings?.guardrails?.map((g) => g.metricId) || []);
+    // Check guardrail regression
+    const guardrailsRegressed = resultData
+        ? (resultData.metrics || [])
+            .filter((m) => guardrailIds.has(m.metricId))
+            .some((m) => {
+            const metricInfo = metricLookup.get(m.metricId);
+            const isInverse = metricInfo?.inverse ?? false;
+            return m.variations.slice(1).some((v) => {
+                const analysis = v.analyses?.[0];
+                if (!analysis)
+                    return false;
+                if (analysis.chanceToBeatControl !== undefined) {
+                    return isInverse
+                        ? analysis.chanceToBeatControl > 0.95
+                        : analysis.chanceToBeatControl < 0.05;
+                }
+                return isInverse
+                    ? (analysis.ciLow ?? 0) > 0
+                    : (analysis.ciHigh ?? 0) < 0;
+            });
+        })
+        : false;
+    // Verdict: Match GrowthBook's ExperimentWinRate.tsx exactly
+    // exp.results maps to resultSummary.status in the API
+    const userResult = exp.resultSummary?.status?.toLowerCase() || "";
+    let verdict;
+    if (userResult === "won") {
+        verdict = "won";
+    }
+    else if (userResult === "lost") {
+        verdict = "lost";
+    }
+    else {
+        // Everything else is "inconclusive": dnf, inconclusive, undefined, null, ""
+        verdict = "inconclusive";
+    }
+    // Compute primary metric result for display
+    const primaryMetricResult = resultData
+        ? computePrimaryMetricResult(resultData, metricLookup, goalIds)
+        : null;
+    return {
+        verdict,
+        primaryMetricResult,
+        guardrailsRegressed,
+        srmPassing,
+        srmPValue,
+        totalUsers,
+    };
+}