Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

84.5 KB
Raw Blame
// AUTO-GENERATED from products/experiments/mcp/tools.yaml + OpenAPI — do not edit
import { z } from 'zod'

import type { Schemas } from '@/api/generated'
import * as orvalSchemas from '@/generated/experiments/api'
import { withUiApp } from '@/resources/ui-apps'
import {
    ExperimentVariantNotesSchema,
    ExperimentVariantScreenshotMediaIdsSchema,
    SavedMetricsAttachSchema,
} from '@/schema/tool-inputs'
import { castStringToInt, normalizeParamAliases } from '@/tools/cast-helpers'
import hooks_experimentCreate from '@/tools/experiments/createExperimentHooks'
import hooks_experimentGet from '@/tools/experiments/getExperimentHooks'
import hooks_experimentList from '@/tools/experiments/listExperimentsHooks'
import hooks_experimentUpdate from '@/tools/experiments/updateExperimentHooks'
import hooks_experimentArchive from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentDuplicate from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentEnd from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentFreezeExposure from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentMigrate from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentPause from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentReset from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentResume from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentShipVariant from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentUnarchive from '@/tools/featureFlags/conditionIdHooks'
import hooks_experimentUnfreezeExposure from '@/tools/featureFlags/conditionIdHooks'
import { transformRequestBody, withToolHooks } from '@/tools/tool-hooks'
import {
    withPostHogUrl,
    omitResponseFields,
    pickResponseFields,
    withInformationalResponse,
    type WithPostHogUrl,
    type WithInformationalResponse,
} from '@/tools/tool-utils'
import type { Context, ToolBase, ZodObjectAny } from '@/tools/types'

const ExperimentActivitySchema = () => {
    const ExperimentsActivityRetrieveParams = orvalSchemas.ExperimentsActivityRetrieveParams()
    const ExperimentsActivityRetrieveQueryParams = orvalSchemas.ExperimentsActivityRetrieveQueryParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsActivityRetrieveParams.omit({ project_id: true })
            .extend(ExperimentsActivityRetrieveQueryParams.shape)
            .extend({ id: z.preprocess(castStringToInt, ExperimentsActivityRetrieveParams.shape['id']) })
    )
}

const experimentActivity = (): ToolBase<
    ReturnType<typeof ExperimentActivitySchema>,
    Schemas.ActivityLogPaginatedResponse
> => ({
    name: 'experiment-activity',
    schema: ExperimentActivitySchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentActivitySchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ActivityLogPaginatedResponse>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/activity/`,
            query: {
                limit: params.limit,
                page: params.page,
            },
        })
        return result
    },
})

const ExperimentArchiveSchema = () => {
    const ExperimentsArchiveCreateBody = orvalSchemas.ExperimentsArchiveCreateBody()
    const ExperimentsArchiveCreateParams = orvalSchemas.ExperimentsArchiveCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsArchiveCreateParams.omit({ project_id: true })
            .extend(ExperimentsArchiveCreateBody.shape)
            .extend({ id: z.preprocess(castStringToInt, ExperimentsArchiveCreateParams.shape['id']) })
    )
}

const experimentArchive = (): ToolBase<
    ReturnType<typeof ExperimentArchiveSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-archive',
        schema: ExperimentArchiveSchema(),
        handler: withToolHooks(
            hooks_experimentArchive,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentArchiveSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const body: Record<string, unknown> = {}
                if (params.disable_feature_flag !== undefined) {
                    body['disable_feature_flag'] = params.disable_feature_flag
                }
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/archive/`,
                    body: await transformRequestBody(hooks_experimentArchive, context, params, body),
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentCalculateRunningTimeSchema = () => {
    const ExperimentsCalculateRunningTimeCreateBody = orvalSchemas.ExperimentsCalculateRunningTimeCreateBody()
    return ExperimentsCalculateRunningTimeCreateBody
}

const experimentCalculateRunningTime = (): ToolBase<
    ReturnType<typeof ExperimentCalculateRunningTimeSchema>,
    Schemas.RunningTimeCalculationResult
> => ({
    name: 'experiment-calculate-running-time',
    schema: ExperimentCalculateRunningTimeSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentCalculateRunningTimeSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.metric_type !== undefined) {
            body['metric_type'] = params.metric_type
        }
        if (params.minimum_detectable_effect !== undefined) {
            body['minimum_detectable_effect'] = params.minimum_detectable_effect
        }
        if (params.number_of_variants !== undefined) {
            body['number_of_variants'] = params.number_of_variants
        }
        if (params.exposure_rate_per_day !== undefined) {
            body['exposure_rate_per_day'] = params.exposure_rate_per_day
        }
        if (params.baseline_value !== undefined) {
            body['baseline_value'] = params.baseline_value
        }
        if (params.variance !== undefined) {
            body['variance'] = params.variance
        }
        if (params.baseline_stats !== undefined) {
            body['baseline_stats'] = params.baseline_stats
        }
        const result = await context.api.request<Schemas.RunningTimeCalculationResult>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/calculate_running_time/`,
            body,
        })
        return result
    },
})

const ExperimentCleanupTaskSchema = () => {
    const ExperimentsFlagCleanupTaskRetrieveParams = orvalSchemas.ExperimentsFlagCleanupTaskRetrieveParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsFlagCleanupTaskRetrieveParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsFlagCleanupTaskRetrieveParams.shape['id']),
        })
    )
}

const experimentCleanupTask = (): ToolBase<
    ReturnType<typeof ExperimentCleanupTaskSchema>,
    Schemas.ExperimentFlagCleanupTask
> => ({
    name: 'experiment-cleanup-task',
    schema: ExperimentCleanupTaskSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentCleanupTaskSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ExperimentFlagCleanupTask>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/flag_cleanup_task/`,
        })
        const filtered = omitResponseFields(result, ['can_view_task']) as typeof result
        return filtered
    },
})

const ExperimentCopyToProjectSchema = () => {
    const ExperimentsCopyToProjectCreateBody = orvalSchemas.ExperimentsCopyToProjectCreateBody()
    const ExperimentsCopyToProjectCreateParams = orvalSchemas.ExperimentsCopyToProjectCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsCopyToProjectCreateParams.omit({ project_id: true })
            .extend(ExperimentsCopyToProjectCreateBody.shape)
            .extend({
                id: z.preprocess(castStringToInt, ExperimentsCopyToProjectCreateParams.shape['id']),
                target_team_id: z.preprocess(
                    castStringToInt,
                    ExperimentsCopyToProjectCreateBody.shape['target_team_id']
                ),
            })
    )
}

const experimentCopyToProject = (): ToolBase<ReturnType<typeof ExperimentCopyToProjectSchema>, Schemas.Experiment> => ({
    name: 'experiment-copy-to-project',
    schema: ExperimentCopyToProjectSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentCopyToProjectSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.target_team_id !== undefined) {
            body['target_team_id'] = params.target_team_id
        }
        if (params.feature_flag_key !== undefined) {
            body['feature_flag_key'] = params.feature_flag_key
        }
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        const result = await context.api.request<Schemas.Experiment>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/copy_to_project/`,
            body,
        })
        const filtered = pickResponseFields(result, [
            'id',
            'name',
            'description',
            'type',
            'feature_flag_key',
            'status',
            'archived',
            'start_date',
            'end_date',
            'created_at',
            'parameters',
            'metrics',
            'metrics_secondary',
            'conclusion',
            'conclusion_comment',
        ]) as typeof result
        return filtered
    },
})

const ExperimentCreateSchema = () => {
    const ExperimentsCreateBody = orvalSchemas.ExperimentsCreateBody()
    return ExperimentsCreateBody.omit({
        start_date: true,
        end_date: true,
        parameters: true,
        excluded_variants: true,
        secondary_metrics: true,
        saved_metrics_ids: true,
        filters: true,
        archived: true,
        deleted: true,
        type: true,
        metrics: true,
        metrics_secondary: true,
        scheduling_config: true,
        _create_in_folder: true,
        conclusion: true,
        conclusion_comment: true,
        repository: true,
        primary_metrics_ordered_uuids: true,
        secondary_metrics_ordered_uuids: true,
        only_count_matured_users: true,
        update_feature_flag_params: true,
        version: true,
        original_experiment: true,
    }).extend({
        feature_flag: ExperimentsCreateBody.shape['feature_flag'].describe(
            'Variant split, rollout scope, payloads, and experience continuity for the auto-created feature flag, in the flag\'s own filters shape. This is the canonical input for flag config. If the user mentions a specific percentage, load the configuring-experiment-rollout skill and clarify before setting these values. Set filters.multivariate.variants (each with key and rollout_percentage; percentages must sum to 100) to customize the variant split. Set filters.groups to a single group [{"properties": [], "rollout_percentage": N}] (0-100) to control the overall fraction of users entering the experiment. Default: 50/50 control/test, 100% rollout. Omit this parameter entirely when feature_flag_key refers to a pre-existing flag: the experiment links to that flag as-is and explicit config is rejected. No specific variant key is required. The analysis baseline defaults to the variant keyed `control` (lowercase) when present, else the first variant; override with stats_config.baseline_variant_key. Convention: when the user describes variants as "A/B", "old/new", "original/redesign", or any other natural-language pair without naming explicit keys, key the baseline `control` and keep their wording in the variant `name`. When the user asks for specific keys, use them as-is and put the baseline first.'
        ),
        running_time_calculation: ExperimentsCreateBody.shape['running_time_calculation'].describe(
            "Persist a running-time / sample-size plan onto the experiment (the planning target shown in the experiment's running-time panel). Object with optional keys: minimum_detectable_effect (percentage, e.g. 20 for a 20% lift), recommended_sample_size (total across all variants), recommended_running_time (days), and exposure_estimate_config. When minimum_detectable_effect is omitted, the project's default MDE is stored instead, if the project has one."
        ),
        variant_notes: ExperimentVariantNotesSchema,
        variant_screenshot_media_ids: ExperimentVariantScreenshotMediaIdsSchema,
    })
}

const experimentCreate = (): ToolBase<ReturnType<typeof ExperimentCreateSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-create',
        schema: ExperimentCreateSchema(),
        handler: withToolHooks(
            hooks_experimentCreate,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentCreateSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const body: Record<string, unknown> = {}
                if (params.name !== undefined) {
                    body['name'] = params.name
                }
                if (params.description !== undefined) {
                    body['description'] = params.description
                }
                if (params.feature_flag_key !== undefined) {
                    body['feature_flag_key'] = params.feature_flag_key
                }
                if (params.feature_flag !== undefined) {
                    body['feature_flag'] = params.feature_flag
                }
                if (params.holdout_id !== undefined) {
                    body['holdout_id'] = params.holdout_id
                }
                if (params.running_time_calculation !== undefined) {
                    body['running_time_calculation'] = params.running_time_calculation
                }
                if (params.exposure_criteria !== undefined) {
                    body['exposure_criteria'] = params.exposure_criteria
                }
                if (params.stats_config !== undefined) {
                    body['stats_config'] = params.stats_config
                }
                if (params.allow_unknown_events !== undefined) {
                    body['allow_unknown_events'] = params.allow_unknown_events
                }
                if (params.tags !== undefined) {
                    body['tags'] = params.tags
                }
                if (params.variant_notes !== undefined) {
                    body['variant_notes'] = params.variant_notes
                }
                if (params.variant_screenshot_media_ids !== undefined) {
                    body['variant_screenshot_media_ids'] = params.variant_screenshot_media_ids
                }
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/`,
                    body: await transformRequestBody(hooks_experimentCreate, context, params, body),
                })
                const filtered = pickResponseFields(result, [
                    'id',
                    'name',
                    'description',
                    'type',
                    'feature_flag_key',
                    'status',
                    'archived',
                    'start_date',
                    'end_date',
                    'created_at',
                    'running_time_calculation',
                    'parameters.variant_notes',
                    'parameters.variant_screenshot_media_ids',
                    'metrics',
                    'metrics_secondary',
                    'conclusion',
                    'conclusion_comment',
                    'tags',
                ]) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentCreateFromPromptSchema = () => {
    const ExperimentsCreateFromPromptCreateBody = orvalSchemas.ExperimentsCreateFromPromptCreateBody()
    return ExperimentsCreateFromPromptCreateBody
}

const experimentCreateFromPrompt = (): ToolBase<
    ReturnType<typeof ExperimentCreateFromPromptSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-create-from-prompt',
        schema: ExperimentCreateFromPromptSchema(),
        handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentCreateFromPromptSchema>>) => {
            const projectId = await context.stateManager.getProjectId()
            const body: Record<string, unknown> = {}
            if (params.prompt_name !== undefined) {
                body['prompt_name'] = params.prompt_name
            }
            if (params.versions !== undefined) {
                body['versions'] = params.versions
            }
            if (params.templates !== undefined) {
                body['templates'] = params.templates
            }
            if (params.name !== undefined) {
                body['name'] = params.name
            }
            if (params.feature_flag_key !== undefined) {
                body['feature_flag_key'] = params.feature_flag_key
            }
            if (params.description !== undefined) {
                body['description'] = params.description
            }
            const result = await context.api.request<Schemas.Experiment>({
                method: 'POST',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/create_from_prompt/`,
                body,
            })
            const filtered = pickResponseFields(result, [
                'id',
                'name',
                'description',
                'type',
                'feature_flag_key',
                'status',
                'archived',
                'start_date',
                'end_date',
                'created_at',
                'metrics',
                'metrics_secondary',
                'conclusion',
                'conclusion_comment',
            ]) as typeof result
            return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
        },
    })

const ExperimentDeleteSchema = () => {
    const ExperimentsDestroyParams = orvalSchemas.ExperimentsDestroyParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsDestroyParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsDestroyParams.shape['id']),
        })
    )
}

const experimentDelete = (): ToolBase<ReturnType<typeof ExperimentDeleteSchema>, Schemas.Experiment> => ({
    name: 'experiment-delete',
    schema: ExperimentDeleteSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentDeleteSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.Experiment>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/`,
            body: { deleted: true },
        })
        const filtered = pickResponseFields(result, ['id', 'name', 'deleted']) as typeof result
        return filtered
    },
})

const ExperimentDuplicateSchema = () => {
    const ExperimentsDuplicateCreateBody = orvalSchemas.ExperimentsDuplicateCreateBody()
    const ExperimentsDuplicateCreateParams = orvalSchemas.ExperimentsDuplicateCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsDuplicateCreateParams.omit({ project_id: true })
            .extend(
                ExperimentsDuplicateCreateBody.omit({
                    description: true,
                    start_date: true,
                    end_date: true,
                    holdout_id: true,
                    parameters: true,
                    running_time_calculation: true,
                    excluded_variants: true,
                    secondary_metrics: true,
                    saved_metrics_ids: true,
                    filters: true,
                    archived: true,
                    deleted: true,
                    type: true,
                    exposure_criteria: true,
                    metrics: true,
                    metrics_secondary: true,
                    stats_config: true,
                    scheduling_config: true,
                    allow_unknown_events: true,
                    _create_in_folder: true,
                    conclusion: true,
                    conclusion_comment: true,
                    repository: true,
                    primary_metrics_ordered_uuids: true,
                    secondary_metrics_ordered_uuids: true,
                    only_count_matured_users: true,
                    update_feature_flag_params: true,
                    version: true,
                    original_experiment: true,
                    tags: true,
                }).shape
            )
            .extend({ id: z.preprocess(castStringToInt, ExperimentsDuplicateCreateParams.shape['id']) })
    )
}

const experimentDuplicate = (): ToolBase<ReturnType<typeof ExperimentDuplicateSchema>, unknown> => ({
    name: 'experiment-duplicate',
    schema: ExperimentDuplicateSchema(),
    handler: withToolHooks(
        hooks_experimentDuplicate,
        async (context: Context, params: z.infer<ReturnType<typeof ExperimentDuplicateSchema>>) => {
            const projectId = await context.stateManager.getProjectId()
            const body: Record<string, unknown> = {}
            if (params.name !== undefined) {
                body['name'] = params.name
            }
            if (params.feature_flag_key !== undefined) {
                body['feature_flag_key'] = params.feature_flag_key
            }
            const result = await context.api.request<unknown>({
                method: 'POST',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/duplicate/`,
                body: await transformRequestBody(hooks_experimentDuplicate, context, params, body),
            })
            const filtered = omitResponseFields(result, ['health']) as typeof result
            return filtered
        }
    ),
})

const ExperimentEndSchema = () => {
    const ExperimentsEndCreateBody = orvalSchemas.ExperimentsEndCreateBody()
    const ExperimentsEndCreateParams = orvalSchemas.ExperimentsEndCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsEndCreateParams.omit({ project_id: true })
            .extend(ExperimentsEndCreateBody.shape)
            .extend({
                id: z.preprocess(castStringToInt, ExperimentsEndCreateParams.shape['id']),
                open_cleanup_pr: ExperimentsEndCreateBody.shape['open_cleanup_pr'].describe(
                    "When true, a background PostHog Code task removes the experiment's feature flag code and opens a draft pull request. Only works for teams with the flag cleanup feature enabled; silently skipped otherwise. Additionally requires the task:write scope. Ask the user before setting this."
                ),
                repository: ExperimentsEndCreateBody.shape['repository'].describe(
                    "Repository the cleanup pull request targets, as \"organization/repository\". Must be connected to the team's GitHub integration. Omit to fall back to the experiment's saved repository, the team default, or the team's only connected repository. When several repositories are connected and no default is set, the cleanup is skipped unless this is provided."
                ),
            })
    )
}

const experimentEnd = (): ToolBase<ReturnType<typeof ExperimentEndSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-end',
        schema: ExperimentEndSchema(),
        handler: withToolHooks(
            hooks_experimentEnd,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentEndSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const body: Record<string, unknown> = {}
                if (params.conclusion !== undefined) {
                    body['conclusion'] = params.conclusion
                }
                if (params.conclusion_comment !== undefined) {
                    body['conclusion_comment'] = params.conclusion_comment
                }
                if (params.open_cleanup_pr !== undefined) {
                    body['open_cleanup_pr'] = params.open_cleanup_pr
                }
                if (params.repository !== undefined) {
                    body['repository'] = params.repository
                }
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/end/`,
                    body: await transformRequestBody(hooks_experimentEnd, context, params, body),
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentFreezeExposureSchema = () => {
    const ExperimentsFreezeExposureCreateParams = orvalSchemas.ExperimentsFreezeExposureCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsFreezeExposureCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsFreezeExposureCreateParams.shape['id']),
        })
    )
}

const experimentFreezeExposure = (): ToolBase<
    ReturnType<typeof ExperimentFreezeExposureSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-freeze-exposure',
        schema: ExperimentFreezeExposureSchema(),
        handler: withToolHooks(
            hooks_experimentFreezeExposure,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentFreezeExposureSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/freeze_exposure/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentGetSchema = () => {
    const ExperimentsRetrieveParams = orvalSchemas.ExperimentsRetrieveParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsRetrieveParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsRetrieveParams.shape['id']),
        })
    )
}

const experimentGet = (): ToolBase<ReturnType<typeof ExperimentGetSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-get',
        schema: ExperimentGetSchema(),
        handler: withToolHooks(
            hooks_experimentGet,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentGetSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'GET',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/`,
                })
                const filtered = omitResponseFields(result, [
                    'saved_metrics.*.effective_query',
                    'health',
                ]) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentHoldoutsCreateSchema = () => {
    const ExperimentHoldoutsCreateBody = orvalSchemas.ExperimentHoldoutsCreateBody()
    return ExperimentHoldoutsCreateBody.extend({
        filters: ExperimentHoldoutsCreateBody.shape['filters'].describe(
            'Non-empty list of release-condition groups defining the held-out population. Each element needs a `rollout_percentage` (0–100, may be fractional) — this is the EXCLUSION percentage, i.e. the share of users held back from every experiment that references this holdout. `properties` optionally narrows the group by person/group properties (same shape as feature-flag release conditions); pass an empty array for an unconditional holdout. Do NOT set `variant` — the server sets it to `holdout-{id}` automatically. Only the first element\'s `rollout_percentage` is embedded into each linked experiment\'s feature flag. Example: [{ "rollout_percentage": 10, "properties": [] }].'
        ),
    })
}

const experimentHoldoutsCreate = (): ToolBase<
    ReturnType<typeof ExperimentHoldoutsCreateSchema>,
    Schemas.ExperimentHoldout
> => ({
    name: 'experiment-holdouts-create',
    schema: ExperimentHoldoutsCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentHoldoutsCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        const result = await context.api.request<Schemas.ExperimentHoldout>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_holdouts/`,
            body,
        })
        return result
    },
})

const ExperimentHoldoutsDestroySchema = () => {
    const ExperimentHoldoutsDestroyParams = orvalSchemas.ExperimentHoldoutsDestroyParams()
    return ExperimentHoldoutsDestroyParams.omit({ project_id: true }).extend({
        id: z.preprocess(castStringToInt, ExperimentHoldoutsDestroyParams.shape['id']),
    })
}

const experimentHoldoutsDestroy = (): ToolBase<ReturnType<typeof ExperimentHoldoutsDestroySchema>, unknown> => ({
    name: 'experiment-holdouts-destroy',
    schema: ExperimentHoldoutsDestroySchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentHoldoutsDestroySchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<unknown>({
            method: 'DELETE',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_holdouts/${encodeURIComponent(String(params.id))}/`,
        })
        return result
    },
})

const ExperimentHoldoutsListSchema = () => {
    const ExperimentHoldoutsListQueryParams = orvalSchemas.ExperimentHoldoutsListQueryParams()
    return ExperimentHoldoutsListQueryParams
}

const experimentHoldoutsList = (): ToolBase<
    ReturnType<typeof ExperimentHoldoutsListSchema>,
    WithPostHogUrl<Schemas.PaginatedExperimentHoldoutList>
> => ({
    name: 'experiment-holdouts-list',
    schema: ExperimentHoldoutsListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentHoldoutsListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedExperimentHoldoutList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_holdouts/`,
            query: {
                limit: params.limit,
                offset: params.offset,
            },
        })
        const filtered = {
            ...result,
            results: (result.results ?? []).map((item: any) =>
                pickResponseFields(item, ['id', 'name', 'description', 'filters', 'created_at', 'updated_at'])
            ),
        } as typeof result
        return await withPostHogUrl(context, filtered, '/experiments')
    },
})

const ExperimentHoldoutsPartialUpdateSchema = () => {
    const ExperimentHoldoutsPartialUpdateBody = orvalSchemas.ExperimentHoldoutsPartialUpdateBody()
    const ExperimentHoldoutsPartialUpdateParams = orvalSchemas.ExperimentHoldoutsPartialUpdateParams()
    return ExperimentHoldoutsPartialUpdateParams.omit({ project_id: true })
        .extend(ExperimentHoldoutsPartialUpdateBody.shape)
        .extend({
            id: z.preprocess(castStringToInt, ExperimentHoldoutsPartialUpdateParams.shape['id']),
            filters: ExperimentHoldoutsPartialUpdateBody.shape['filters'].describe(
                'Non-empty list of release-condition groups defining the held-out population. Each element needs a `rollout_percentage` (0–100, may be fractional) — the EXCLUSION percentage. Do NOT set `variant` (the server manages it as `holdout-{id}`). Changing this cascades to every linked experiment\'s feature flag. Example: [{ "rollout_percentage": 10, "properties": [] }].'
            ),
        })
}

const experimentHoldoutsPartialUpdate = (): ToolBase<
    ReturnType<typeof ExperimentHoldoutsPartialUpdateSchema>,
    Schemas.ExperimentHoldout
> => ({
    name: 'experiment-holdouts-partial-update',
    schema: ExperimentHoldoutsPartialUpdateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentHoldoutsPartialUpdateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        const result = await context.api.request<Schemas.ExperimentHoldout>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_holdouts/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

const ExperimentHoldoutsRetrieveSchema = () => {
    const ExperimentHoldoutsRetrieveParams = orvalSchemas.ExperimentHoldoutsRetrieveParams()
    return ExperimentHoldoutsRetrieveParams.omit({ project_id: true }).extend({
        id: z.preprocess(castStringToInt, ExperimentHoldoutsRetrieveParams.shape['id']),
    })
}

const experimentHoldoutsRetrieve = (): ToolBase<
    ReturnType<typeof ExperimentHoldoutsRetrieveSchema>,
    Schemas.ExperimentHoldout
> => ({
    name: 'experiment-holdouts-retrieve',
    schema: ExperimentHoldoutsRetrieveSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentHoldoutsRetrieveSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ExperimentHoldout>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_holdouts/${encodeURIComponent(String(params.id))}/`,
        })
        return result
    },
})

const ExperimentLaunchSchema = () => {
    const ExperimentsLaunchCreateParams = orvalSchemas.ExperimentsLaunchCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsLaunchCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsLaunchCreateParams.shape['id']),
        })
    )
}

const experimentLaunch = (): ToolBase<ReturnType<typeof ExperimentLaunchSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-launch',
        schema: ExperimentLaunchSchema(),
        handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentLaunchSchema>>) => {
            const projectId = await context.stateManager.getProjectId()
            const result = await context.api.request<Schemas.Experiment>({
                method: 'POST',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/launch/`,
            })
            const filtered = pickResponseFields(result, [
                'id',
                'name',
                'description',
                'type',
                'feature_flag_key',
                'status',
                'archived',
                'start_date',
                'end_date',
                'created_at',
                'parameters',
                'metrics',
                'metrics_secondary',
                'conclusion',
                'conclusion_comment',
            ]) as typeof result
            return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
        },
    })

const ExperimentListSchema = () => {
    const ExperimentsListQueryParams = orvalSchemas.ExperimentsListQueryParams()
    return ExperimentsListQueryParams.extend({
        status: ExperimentsListQueryParams.shape['status'].describe(
            'Filter by experiment status. Values: "draft" (not yet launched), "running" (launched, flag active), "paused" (launched, flag deactivated — mutually exclusive with running), "exposure_frozen" (launched, enrollment frozen to the already-exposed cohort while metrics keep flowing), "stopped" or "complete" (both mean ended), "all" (no filter). Defaults to all non-archived experiments.'
        ),
        limit: z.preprocess(castStringToInt, ExperimentsListQueryParams.shape['limit']).optional(),
        offset: z.preprocess(castStringToInt, ExperimentsListQueryParams.shape['offset']).optional(),
        feature_flag_id: z.preprocess(castStringToInt, ExperimentsListQueryParams.shape['feature_flag_id']).optional(),
    })
}

const experimentList = (): ToolBase<
    ReturnType<typeof ExperimentListSchema>,
    WithPostHogUrl<Schemas.PaginatedExperimentBasicList>
> =>
    withUiApp('experiment-list', {
        name: 'experiment-list',
        schema: ExperimentListSchema(),
        handler: withToolHooks(
            hooks_experimentList,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentListSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.PaginatedExperimentBasicList>({
                    method: 'GET',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/`,
                    query: {
                        archived: params.archived,
                        created_by_id: params.created_by_id,
                        event: params.event,
                        excluded_tags: params.excluded_tags,
                        feature_flag_id: params.feature_flag_id,
                        limit: params.limit,
                        offset: params.offset,
                        order: params.order,
                        prompt_name: params.prompt_name,
                        search: params.search,
                        status: params.status,
                        tags: params.tags,
                    },
                })
                const filtered = {
                    ...result,
                    results: (result.results ?? []).map((item: any) =>
                        pickResponseFields(item, [
                            'id',
                            'name',
                            'description',
                            'feature_flag_key',
                            'feature_flag',
                            'start_date',
                            'end_date',
                            'archived',
                            'type',
                            'status',
                            'created_at',
                            'updated_at',
                            'tags',
                            'parameters.variant_notes',
                            'parameters.variant_screenshot_media_ids',
                        ])
                    ),
                } as typeof result
                return await withPostHogUrl(
                    context,
                    {
                        ...filtered,
                        results: await Promise.all(
                            (filtered.results ?? []).map((item) =>
                                withPostHogUrl(context, item, `/experiments/${item.id}`)
                            )
                        ),
                    },
                    '/experiments'
                )
            }
        ),
    })

const ExperimentMetricsRecalculationCreateSchema = () => {
    const ExperimentsMetricsRecalculationCreateBody = orvalSchemas.ExperimentsMetricsRecalculationCreateBody()
    const ExperimentsMetricsRecalculationCreateParams = orvalSchemas.ExperimentsMetricsRecalculationCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsMetricsRecalculationCreateParams.omit({ project_id: true })
            .extend(ExperimentsMetricsRecalculationCreateBody.shape)
            .extend({ id: z.preprocess(castStringToInt, ExperimentsMetricsRecalculationCreateParams.shape['id']) })
    )
}

const experimentMetricsRecalculationCreate = (): ToolBase<
    ReturnType<typeof ExperimentMetricsRecalculationCreateSchema>,
    WithPostHogUrl<Schemas.ExperimentMetricsRecalculationJob>
> => ({
    name: 'experiment-metrics-recalculation-create',
    schema: ExperimentMetricsRecalculationCreateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ExperimentMetricsRecalculationCreateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ExperimentMetricsRecalculationJob>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/metrics_recalculation/`,
        })
        return await withPostHogUrl(context, result, `/experiments/${params.id}`)
    },
})

const ExperimentMetricsRecalculationLatestRetrieveSchema = () => {
    const ExperimentsMetricsRecalculationLatestRetrieveParams =
        orvalSchemas.ExperimentsMetricsRecalculationLatestRetrieveParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsMetricsRecalculationLatestRetrieveParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsMetricsRecalculationLatestRetrieveParams.shape['id']),
        })
    )
}

const experimentMetricsRecalculationLatestRetrieve = (): ToolBase<
    ReturnType<typeof ExperimentMetricsRecalculationLatestRetrieveSchema>,
    WithPostHogUrl<Schemas.ExperimentMetricsRecalculationLatest>
> =>
    withUiApp('experiment-results', {
        name: 'experiment-metrics-recalculation-latest-retrieve',
        schema: ExperimentMetricsRecalculationLatestRetrieveSchema(),
        handler: async (
            context: Context,
            params: z.infer<ReturnType<typeof ExperimentMetricsRecalculationLatestRetrieveSchema>>
        ) => {
            const projectId = await context.stateManager.getProjectId()
            const result = await context.api.request<Schemas.ExperimentMetricsRecalculationLatest>({
                method: 'GET',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/metrics_recalculation/latest/`,
            })
            const filtered = omitResponseFields(result, [
                'results.*.result.hogql',
                'results.*.result.clickhouse_sql',
                'results.*.result.cache_key',
                'results.*.result.is_cached',
                'results.*.result.cache_target_age',
                'results.*.result.next_allowed_client_refresh',
                'results.*.result.calculation_trigger',
                'results.*.result.query_status',
            ]) as typeof result
            return await withPostHogUrl(context, filtered, `/experiments/${params.id}`)
        },
    })

const ExperimentMetricsRecalculationRetrieveSchema = () => {
    const ExperimentsMetricsRecalculationRetrieveParams = orvalSchemas.ExperimentsMetricsRecalculationRetrieveParams()
    return z.preprocess(
        normalizeParamAliases({
            id: ['experimentId', 'experiment_id'],
            recalculation_id: ['run_id', 'runId', 'recalculationId'],
        }),
        ExperimentsMetricsRecalculationRetrieveParams.omit({ project_id: true }).extend({
            id: z.preprocess(
                castStringToInt,
                ExperimentsMetricsRecalculationRetrieveParams.shape['id'].describe(
                    "The experiment's numeric ID, not the recalculation run UUID. Get it from experiment-get or from the response of experiment-metrics-recalculation-create. The run UUID goes in recalculation_id."
                )
            ),
            recalculation_id: ExperimentsMetricsRecalculationRetrieveParams.shape['recalculation_id'].describe(
                'The recalculation run UUID, from experiment-metrics-recalculation-create or experiment-metrics-recalculation-latest-retrieve.'
            ),
        })
    )
}

const experimentMetricsRecalculationRetrieve = (): ToolBase<
    ReturnType<typeof ExperimentMetricsRecalculationRetrieveSchema>,
    WithPostHogUrl<Schemas.ExperimentMetricsRecalculationRun>
> => ({
    name: 'experiment-metrics-recalculation-retrieve',
    schema: ExperimentMetricsRecalculationRetrieveSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ExperimentMetricsRecalculationRetrieveSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ExperimentMetricsRecalculationRun>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/metrics_recalculation/${encodeURIComponent(String(params.recalculation_id))}/`,
        })
        const filtered = omitResponseFields(result, [
            'results.*.result.hogql',
            'results.*.result.clickhouse_sql',
            'results.*.result.cache_key',
            'results.*.result.is_cached',
            'results.*.result.cache_target_age',
            'results.*.result.next_allowed_client_refresh',
            'results.*.result.calculation_trigger',
            'results.*.result.query_status',
        ]) as typeof result
        return await withPostHogUrl(context, filtered, `/experiments/${params.id}`)
    },
})

const ExperimentMigrateSchema = () => {
    const ExperimentsMigrateCreateParams = orvalSchemas.ExperimentsMigrateCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsMigrateCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsMigrateCreateParams.shape['id']),
        })
    )
}

const experimentMigrate = (): ToolBase<
    ReturnType<typeof ExperimentMigrateSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-migrate',
        schema: ExperimentMigrateSchema(),
        handler: withToolHooks(
            hooks_experimentMigrate,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentMigrateSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/migrate/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentPauseSchema = () => {
    const ExperimentsPauseCreateParams = orvalSchemas.ExperimentsPauseCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsPauseCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsPauseCreateParams.shape['id']),
        })
    )
}

const experimentPause = (): ToolBase<ReturnType<typeof ExperimentPauseSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-pause',
        schema: ExperimentPauseSchema(),
        handler: withToolHooks(
            hooks_experimentPause,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentPauseSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/pause/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentPromptTemplatesSchema = () => z.object({})

const experimentPromptTemplates = (): ToolBase<ReturnType<typeof ExperimentPromptTemplatesSchema>, unknown> => ({
    name: 'experiment-prompt-templates',
    schema: ExperimentPromptTemplatesSchema(),
    handler: async (context: Context, _params: z.infer<ReturnType<typeof ExperimentPromptTemplatesSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<unknown>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/prompt_templates/`,
        })
        return result
    },
})

const ExperimentResetSchema = () => {
    const ExperimentsResetCreateParams = orvalSchemas.ExperimentsResetCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsResetCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsResetCreateParams.shape['id']),
        })
    )
}

const experimentReset = (): ToolBase<ReturnType<typeof ExperimentResetSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-reset',
        schema: ExperimentResetSchema(),
        handler: withToolHooks(
            hooks_experimentReset,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentResetSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/reset/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentResumeSchema = () => {
    const ExperimentsResumeCreateParams = orvalSchemas.ExperimentsResumeCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsResumeCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsResumeCreateParams.shape['id']),
        })
    )
}

const experimentResume = (): ToolBase<ReturnType<typeof ExperimentResumeSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-resume',
        schema: ExperimentResumeSchema(),
        handler: withToolHooks(
            hooks_experimentResume,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentResumeSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/resume/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentSavedMetricsCreateSchema = () => {
    const ExperimentSavedMetricsCreateBody = orvalSchemas.ExperimentSavedMetricsCreateBody()
    return ExperimentSavedMetricsCreateBody
}

const experimentSavedMetricsCreate = (): ToolBase<
    ReturnType<typeof ExperimentSavedMetricsCreateSchema>,
    Schemas.ExperimentSavedMetric
> => ({
    name: 'experiment-saved-metrics-create',
    schema: ExperimentSavedMetricsCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentSavedMetricsCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        if (params.query !== undefined) {
            body['query'] = params.query
        }
        if (params.tags !== undefined) {
            body['tags'] = params.tags
        }
        const result = await context.api.request<Schemas.ExperimentSavedMetric>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_saved_metrics/`,
            body,
        })
        return result
    },
})

const ExperimentSavedMetricsDestroySchema = () => {
    const ExperimentSavedMetricsDestroyParams = orvalSchemas.ExperimentSavedMetricsDestroyParams()
    return ExperimentSavedMetricsDestroyParams.omit({ project_id: true }).extend({
        id: z.preprocess(castStringToInt, ExperimentSavedMetricsDestroyParams.shape['id']),
    })
}

const experimentSavedMetricsDestroy = (): ToolBase<
    ReturnType<typeof ExperimentSavedMetricsDestroySchema>,
    unknown
> => ({
    name: 'experiment-saved-metrics-destroy',
    schema: ExperimentSavedMetricsDestroySchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentSavedMetricsDestroySchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<unknown>({
            method: 'DELETE',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_saved_metrics/${encodeURIComponent(String(params.id))}/`,
        })
        return result
    },
})

const ExperimentSavedMetricsListSchema = () => {
    const ExperimentSavedMetricsListQueryParams = orvalSchemas.ExperimentSavedMetricsListQueryParams()
    return ExperimentSavedMetricsListQueryParams.extend({
        limit: z.preprocess(castStringToInt, ExperimentSavedMetricsListQueryParams.shape['limit']).optional(),
        offset: z.preprocess(castStringToInt, ExperimentSavedMetricsListQueryParams.shape['offset']).optional(),
        event: ExperimentSavedMetricsListQueryParams.shape['event'].describe(
            "Filter to shared metrics whose query references this event name — matched directly (an EventsNode) or via the step events of any action the metric references. For finding a reusable metric by what it measures; then confirm the match against each row's 'query'."
        ),
    })
}

const experimentSavedMetricsList = (): ToolBase<
    ReturnType<typeof ExperimentSavedMetricsListSchema>,
    WithPostHogUrl<Schemas.PaginatedExperimentSavedMetricList>
> => ({
    name: 'experiment-saved-metrics-list',
    schema: ExperimentSavedMetricsListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentSavedMetricsListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedExperimentSavedMetricList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_saved_metrics/`,
            query: {
                event: params.event,
                limit: params.limit,
                offset: params.offset,
                search: params.search,
            },
        })
        const filtered = {
            ...result,
            results: (result.results ?? []).map((item: any) =>
                pickResponseFields(item, ['id', 'name', 'description', 'query', 'created_at', 'updated_at', 'tags'])
            ),
        } as typeof result
        return await withPostHogUrl(context, filtered, '/experiments')
    },
})

const ExperimentSavedMetricsPartialUpdateSchema = () => {
    const ExperimentSavedMetricsPartialUpdateBody = orvalSchemas.ExperimentSavedMetricsPartialUpdateBody()
    const ExperimentSavedMetricsPartialUpdateParams = orvalSchemas.ExperimentSavedMetricsPartialUpdateParams()
    return ExperimentSavedMetricsPartialUpdateParams.omit({ project_id: true })
        .extend(ExperimentSavedMetricsPartialUpdateBody.shape)
        .extend({ id: z.preprocess(castStringToInt, ExperimentSavedMetricsPartialUpdateParams.shape['id']) })
}

const experimentSavedMetricsPartialUpdate = (): ToolBase<
    ReturnType<typeof ExperimentSavedMetricsPartialUpdateSchema>,
    Schemas.ExperimentSavedMetric
> => ({
    name: 'experiment-saved-metrics-partial-update',
    schema: ExperimentSavedMetricsPartialUpdateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ExperimentSavedMetricsPartialUpdateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        if (params.query !== undefined) {
            body['query'] = params.query
        }
        if (params.tags !== undefined) {
            body['tags'] = params.tags
        }
        const result = await context.api.request<Schemas.ExperimentSavedMetric>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_saved_metrics/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

const ExperimentSavedMetricsRetrieveSchema = () => {
    const ExperimentSavedMetricsRetrieveParams = orvalSchemas.ExperimentSavedMetricsRetrieveParams()
    return ExperimentSavedMetricsRetrieveParams.omit({ project_id: true }).extend({
        id: z.preprocess(castStringToInt, ExperimentSavedMetricsRetrieveParams.shape['id']),
    })
}

const experimentSavedMetricsRetrieve = (): ToolBase<
    ReturnType<typeof ExperimentSavedMetricsRetrieveSchema>,
    Schemas.ExperimentSavedMetric
> => ({
    name: 'experiment-saved-metrics-retrieve',
    schema: ExperimentSavedMetricsRetrieveSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentSavedMetricsRetrieveSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ExperimentSavedMetric>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiment_saved_metrics/${encodeURIComponent(String(params.id))}/`,
        })
        return result
    },
})

const ExperimentSetupContextSchema = () => {
    const ExperimentsSetupContextCreateBody = orvalSchemas.ExperimentsSetupContextCreateBody()
    return ExperimentsSetupContextCreateBody
}

const experimentSetupContext = (): ToolBase<
    ReturnType<typeof ExperimentSetupContextSchema>,
    WithInformationalResponse<Schemas.ExperimentSetupContextResponse>
> => ({
    name: 'experiment-setup-context',
    schema: ExperimentSetupContextSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentSetupContextSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.target_event !== undefined) {
            body['target_event'] = params.target_event
        }
        if (params.target_url_contains !== undefined) {
            body['target_url_contains'] = params.target_url_contains
        }
        if (params.target_properties !== undefined) {
            body['target_properties'] = params.target_properties
        }
        if (params.metric_event !== undefined) {
            body['metric_event'] = params.metric_event
        }
        if (params.metric_properties !== undefined) {
            body['metric_properties'] = params.metric_properties
        }
        if (params.previous_experiments_limit !== undefined) {
            body['previous_experiments_limit'] = params.previous_experiments_limit
        }
        if (params.shared_metrics_limit !== undefined) {
            body['shared_metrics_limit'] = params.shared_metrics_limit
        }
        const result = await context.api.request<Schemas.ExperimentSetupContextResponse>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/setup_context/`,
            body,
        })
        return withInformationalResponse(
            result,
            'experiment-setup-context',
            'Use it only as facts about this project when configuring a new experiment.'
        )
    },
})

const ExperimentShipVariantSchema = () => {
    const ExperimentsShipVariantCreateBody = orvalSchemas.ExperimentsShipVariantCreateBody()
    const ExperimentsShipVariantCreateParams = orvalSchemas.ExperimentsShipVariantCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsShipVariantCreateParams.omit({ project_id: true })
            .extend(ExperimentsShipVariantCreateBody.shape)
            .extend({
                id: z.preprocess(castStringToInt, ExperimentsShipVariantCreateParams.shape['id']),
                open_cleanup_pr: ExperimentsShipVariantCreateBody.shape['open_cleanup_pr'].describe(
                    "When true, a background PostHog Code task removes the experiment's feature flag code, keeping the shipped variant's code path, and opens a draft pull request. Only works for teams with the flag cleanup feature enabled; silently skipped otherwise. Additionally requires the task:write scope. Ask the user before setting this."
                ),
                repository: ExperimentsShipVariantCreateBody.shape['repository'].describe(
                    "Repository the cleanup pull request targets, as \"organization/repository\". Must be connected to the team's GitHub integration. Omit to fall back to the experiment's saved repository, the team default, or the team's only connected repository. When several repositories are connected and no default is set, the cleanup is skipped unless this is provided."
                ),
            })
    )
}

const experimentShipVariant = (): ToolBase<
    ReturnType<typeof ExperimentShipVariantSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-ship-variant',
        schema: ExperimentShipVariantSchema(),
        handler: withToolHooks(
            hooks_experimentShipVariant,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentShipVariantSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const body: Record<string, unknown> = {}
                if (params.conclusion !== undefined) {
                    body['conclusion'] = params.conclusion
                }
                if (params.conclusion_comment !== undefined) {
                    body['conclusion_comment'] = params.conclusion_comment
                }
                if (params.open_cleanup_pr !== undefined) {
                    body['open_cleanup_pr'] = params.open_cleanup_pr
                }
                if (params.repository !== undefined) {
                    body['repository'] = params.repository
                }
                if (params.variant_key !== undefined) {
                    body['variant_key'] = params.variant_key
                }
                if (params.release_to_everyone !== undefined) {
                    body['release_to_everyone'] = params.release_to_everyone
                }
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/ship_variant/`,
                    body: await transformRequestBody(hooks_experimentShipVariant, context, params, body),
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentStatsSchema = () => z.object({})

const experimentStats = (): ToolBase<ReturnType<typeof ExperimentStatsSchema>, unknown> => ({
    name: 'experiment-stats',
    schema: ExperimentStatsSchema(),
    handler: async (context: Context, _params: z.infer<ReturnType<typeof ExperimentStatsSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<unknown>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/stats/`,
        })
        return result
    },
})

const ExperimentTimeseriesResultsSchema = () => {
    const ExperimentsTimeseriesResultsRetrieveParams = orvalSchemas.ExperimentsTimeseriesResultsRetrieveParams()
    const ExperimentsTimeseriesResultsRetrieveQueryParams =
        orvalSchemas.ExperimentsTimeseriesResultsRetrieveQueryParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsTimeseriesResultsRetrieveParams.omit({ project_id: true })
            .extend(ExperimentsTimeseriesResultsRetrieveQueryParams.shape)
            .extend({ id: z.preprocess(castStringToInt, ExperimentsTimeseriesResultsRetrieveParams.shape['id']) })
    )
}

const experimentTimeseriesResults = (): ToolBase<ReturnType<typeof ExperimentTimeseriesResultsSchema>, unknown> => ({
    name: 'experiment-timeseries-results',
    schema: ExperimentTimeseriesResultsSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentTimeseriesResultsSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<unknown>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/timeseries_results/`,
            query: {
                fingerprint: params.fingerprint,
                metric_uuid: params.metric_uuid,
            },
        })
        const filtered = omitResponseFields(result, [
            'timeseries.*.hogql',
            'timeseries.*.clickhouse_sql',
            'timeseries.*.cache_key',
            'timeseries.*.is_cached',
            'timeseries.*.cache_target_age',
            'timeseries.*.next_allowed_client_refresh',
            'timeseries.*.calculation_trigger',
            'timeseries.*.query_status',
        ]) as typeof result
        return filtered
    },
})

const ExperimentUnarchiveSchema = () => {
    const ExperimentsUnarchiveCreateParams = orvalSchemas.ExperimentsUnarchiveCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsUnarchiveCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsUnarchiveCreateParams.shape['id']),
        })
    )
}

const experimentUnarchive = (): ToolBase<
    ReturnType<typeof ExperimentUnarchiveSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-unarchive',
        schema: ExperimentUnarchiveSchema(),
        handler: withToolHooks(
            hooks_experimentUnarchive,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentUnarchiveSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/unarchive/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentUnfreezeExposureSchema = () => {
    const ExperimentsUnfreezeExposureCreateParams = orvalSchemas.ExperimentsUnfreezeExposureCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsUnfreezeExposureCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsUnfreezeExposureCreateParams.shape['id']),
        })
    )
}

const experimentUnfreezeExposure = (): ToolBase<
    ReturnType<typeof ExperimentUnfreezeExposureSchema>,
    WithPostHogUrl<Schemas.Experiment>
> =>
    withUiApp('experiment', {
        name: 'experiment-unfreeze-exposure',
        schema: ExperimentUnfreezeExposureSchema(),
        handler: withToolHooks(
            hooks_experimentUnfreezeExposure,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentUnfreezeExposureSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'POST',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/unfreeze_exposure/`,
                })
                const filtered = omitResponseFields(result, ['health']) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentUpdateSchema = () => {
    const ExperimentsPartialUpdateBody = orvalSchemas.ExperimentsPartialUpdateBody()
    const ExperimentsPartialUpdateParams = orvalSchemas.ExperimentsPartialUpdateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsPartialUpdateParams.omit({ project_id: true })
            .extend(
                ExperimentsPartialUpdateBody.omit({
                    start_date: true,
                    end_date: true,
                    feature_flag_key: true,
                    parameters: true,
                    secondary_metrics: true,
                    filters: true,
                    deleted: true,
                    type: true,
                    scheduling_config: true,
                    _create_in_folder: true,
                    repository: true,
                    primary_metrics_ordered_uuids: true,
                    secondary_metrics_ordered_uuids: true,
                    only_count_matured_users: true,
                    version: true,
                    original_experiment: true,
                }).shape
            )
            .extend({
                id: z.preprocess(castStringToInt, ExperimentsPartialUpdateParams.shape['id']),
                feature_flag: ExperimentsPartialUpdateBody.shape['feature_flag'].describe(
                    "Variant split, rollout scope, payloads, and experience continuity for the linked feature flag, in the flag's own filters shape. This is the canonical input for flag config. Set filters.multivariate.variants (each with key and rollout_percentage; percentages must sum to 100; the analysis baseline defaults to the variant keyed 'control' when present, else the first variant — except web experiments, which must keep a variant keyed 'control') to change the variant split. Set filters.groups to a single group [{\"properties\": [], \"rollout_percentage\": N}] (0-100) to change the overall rollout. Config this object omits is preserved from the flag's current state. On a running experiment this requires update_feature_flag_params=true (see rule 1: warn the user first)."
                ),
                running_time_calculation: ExperimentsPartialUpdateBody.shape['running_time_calculation'].describe(
                    "Persist a running-time / sample-size plan onto the experiment (the planning target shown in the experiment's running-time panel). Object with optional keys: minimum_detectable_effect (percentage, e.g. 20 for a 20% lift), recommended_sample_size (total across all variants), recommended_running_time (days), and exposure_estimate_config."
                ),
                saved_metrics_ids: SavedMetricsAttachSchema.optional(),
                variant_notes: ExperimentVariantNotesSchema.optional(),
                variant_screenshot_media_ids: ExperimentVariantScreenshotMediaIdsSchema.optional(),
            })
    )
}

const experimentUpdate = (): ToolBase<ReturnType<typeof ExperimentUpdateSchema>, WithPostHogUrl<Schemas.Experiment>> =>
    withUiApp('experiment', {
        name: 'experiment-update',
        schema: ExperimentUpdateSchema(),
        handler: withToolHooks(
            hooks_experimentUpdate,
            async (context: Context, params: z.infer<ReturnType<typeof ExperimentUpdateSchema>>) => {
                const projectId = await context.stateManager.getProjectId()
                const body: Record<string, unknown> = {}
                if (params.name !== undefined) {
                    body['name'] = params.name
                }
                if (params.description !== undefined) {
                    body['description'] = params.description
                }
                if (params.feature_flag !== undefined) {
                    body['feature_flag'] = params.feature_flag
                }
                if (params.holdout_id !== undefined) {
                    body['holdout_id'] = params.holdout_id
                }
                if (params.running_time_calculation !== undefined) {
                    body['running_time_calculation'] = params.running_time_calculation
                }
                if (params.excluded_variants !== undefined) {
                    body['excluded_variants'] = params.excluded_variants
                }
                if (params.saved_metrics_ids !== undefined) {
                    body['saved_metrics_ids'] = params.saved_metrics_ids
                }
                if (params.archived !== undefined) {
                    body['archived'] = params.archived
                }
                if (params.exposure_criteria !== undefined) {
                    body['exposure_criteria'] = params.exposure_criteria
                }
                if (params.metrics !== undefined) {
                    body['metrics'] = params.metrics
                }
                if (params.metrics_secondary !== undefined) {
                    body['metrics_secondary'] = params.metrics_secondary
                }
                if (params.stats_config !== undefined) {
                    body['stats_config'] = params.stats_config
                }
                if (params.allow_unknown_events !== undefined) {
                    body['allow_unknown_events'] = params.allow_unknown_events
                }
                if (params.conclusion !== undefined) {
                    body['conclusion'] = params.conclusion
                }
                if (params.conclusion_comment !== undefined) {
                    body['conclusion_comment'] = params.conclusion_comment
                }
                if (params.update_feature_flag_params !== undefined) {
                    body['update_feature_flag_params'] = params.update_feature_flag_params
                }
                if (params.tags !== undefined) {
                    body['tags'] = params.tags
                }
                if (params.variant_notes !== undefined) {
                    body['variant_notes'] = params.variant_notes
                }
                if (params.variant_screenshot_media_ids !== undefined) {
                    body['variant_screenshot_media_ids'] = params.variant_screenshot_media_ids
                }
                const result = await context.api.request<Schemas.Experiment>({
                    method: 'PATCH',
                    path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/`,
                    body: await transformRequestBody(hooks_experimentUpdate, context, params, body),
                })
                const filtered = pickResponseFields(result, [
                    'id',
                    'name',
                    'description',
                    'type',
                    'feature_flag_key',
                    'status',
                    'archived',
                    'start_date',
                    'end_date',
                    'created_at',
                    'running_time_calculation',
                    'parameters.variant_notes',
                    'parameters.variant_screenshot_media_ids',
                    'excluded_variants',
                    'metrics',
                    'metrics_secondary',
                    'saved_metrics.*.id',
                    'saved_metrics.*.experiment',
                    'saved_metrics.*.saved_metric',
                    'saved_metrics.*.metadata',
                    'saved_metrics.*.created_at',
                    'saved_metrics.*.query',
                    'saved_metrics.*.name',
                    'conclusion',
                    'conclusion_comment',
                    'tags',
                ]) as typeof result
                return await withPostHogUrl(context, filtered, `/experiments/${filtered.id}`)
            }
        ),
    })

const ExperimentsBulkUpdateTagsCreateSchema = () => {
    const ExperimentsBulkUpdateTagsCreateBody = orvalSchemas.ExperimentsBulkUpdateTagsCreateBody()
    return ExperimentsBulkUpdateTagsCreateBody
}

const experimentsBulkUpdateTagsCreate = (): ToolBase<
    ReturnType<typeof ExperimentsBulkUpdateTagsCreateSchema>,
    Schemas.BulkUpdateTagsResponse
> => ({
    name: 'experiments-bulk-update-tags-create',
    schema: ExperimentsBulkUpdateTagsCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ExperimentsBulkUpdateTagsCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.ids !== undefined) {
            body['ids'] = params.ids
        }
        if (params.action !== undefined) {
            body['action'] = params.action
        }
        if (params.tags !== undefined) {
            body['tags'] = params.tags
        }
        const result = await context.api.request<Schemas.BulkUpdateTagsResponse>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/bulk_update_tags/`,
            body,
        })
        return result
    },
})

const ExperimentsSessionEventDeltasCreateSchema = () => {
    const ExperimentsSessionEventDeltasCreateParams = orvalSchemas.ExperimentsSessionEventDeltasCreateParams()
    return z.preprocess(
        normalizeParamAliases({ id: ['experimentId', 'experiment_id'] }),
        ExperimentsSessionEventDeltasCreateParams.omit({ project_id: true }).extend({
            id: z.preprocess(castStringToInt, ExperimentsSessionEventDeltasCreateParams.shape['id']),
        })
    )
}

const experimentsSessionEventDeltasCreate = (): ToolBase<
    ReturnType<typeof ExperimentsSessionEventDeltasCreateSchema>,
    WithInformationalResponse<WithPostHogUrl<Schemas.ExperimentSessionEventDeltaResponse>>
> => ({
    name: 'experiments-session-event-deltas-create',
    schema: ExperimentsSessionEventDeltasCreateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ExperimentsSessionEventDeltasCreateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ExperimentSessionEventDeltaResponse>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/experiments/${encodeURIComponent(String(params.id))}/session_event_deltas/`,
        })
        return withInformationalResponse(
            await withPostHogUrl(context, result, `/experiments/${params.id}`),
            'experiment-watch-cards',
            'Use it only to point the user at recordings worth watching for this experiment.'
        )
    },
})

export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
    'experiment-activity': experimentActivity,
    'experiment-archive': experimentArchive,
    'experiment-calculate-running-time': experimentCalculateRunningTime,
    'experiment-cleanup-task': experimentCleanupTask,
    'experiment-copy-to-project': experimentCopyToProject,
    'experiment-create': experimentCreate,
    'experiment-create-from-prompt': experimentCreateFromPrompt,
    'experiment-delete': experimentDelete,
    'experiment-duplicate': experimentDuplicate,
    'experiment-end': experimentEnd,
    'experiment-freeze-exposure': experimentFreezeExposure,
    'experiment-get': experimentGet,
    'experiment-holdouts-create': experimentHoldoutsCreate,
    'experiment-holdouts-destroy': experimentHoldoutsDestroy,
    'experiment-holdouts-list': experimentHoldoutsList,
    'experiment-holdouts-partial-update': experimentHoldoutsPartialUpdate,
    'experiment-holdouts-retrieve': experimentHoldoutsRetrieve,
    'experiment-launch': experimentLaunch,
    'experiment-list': experimentList,
    'experiment-metrics-recalculation-create': experimentMetricsRecalculationCreate,
    'experiment-metrics-recalculation-latest-retrieve': experimentMetricsRecalculationLatestRetrieve,
    'experiment-metrics-recalculation-retrieve': experimentMetricsRecalculationRetrieve,
    'experiment-migrate': experimentMigrate,
    'experiment-pause': experimentPause,
    'experiment-prompt-templates': experimentPromptTemplates,
    'experiment-reset': experimentReset,
    'experiment-resume': experimentResume,
    'experiment-saved-metrics-create': experimentSavedMetricsCreate,
    'experiment-saved-metrics-destroy': experimentSavedMetricsDestroy,
    'experiment-saved-metrics-list': experimentSavedMetricsList,
    'experiment-saved-metrics-partial-update': experimentSavedMetricsPartialUpdate,
    'experiment-saved-metrics-retrieve': experimentSavedMetricsRetrieve,
    'experiment-setup-context': experimentSetupContext,
    'experiment-ship-variant': experimentShipVariant,
    'experiment-stats': experimentStats,
    'experiment-timeseries-results': experimentTimeseriesResults,
    'experiment-unarchive': experimentUnarchive,
    'experiment-unfreeze-exposure': experimentUnfreezeExposure,
    'experiment-update': experimentUpdate,
    'experiments-bulk-update-tags-create': experimentsBulkUpdateTagsCreate,
    'experiments-session-event-deltas-create': experimentsSessionEventDeltasCreate,
}