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.

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

import type { Schemas } from '@/api/generated'
import * as orvalSchemas from '@/generated/error_tracking/api'
import { withUiApp } from '@/resources/ui-apps'
import { withPostHogUrl, pickResponseFields, withTextProjection, type WithPostHogUrl } from '@/tools/tool-utils'
import type { Context, ToolBase, ZodObjectAny } from '@/tools/types'

const ErrorTrackingAssignmentRulesCreateSchema = () => {
    const ErrorTrackingAssignmentRulesCreateBody = orvalSchemas.ErrorTrackingAssignmentRulesCreateBody()
    return ErrorTrackingAssignmentRulesCreateBody
}

const errorTrackingAssignmentRulesCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingAssignmentRulesCreateSchema>,
    Schemas.ErrorTrackingAssignmentRule
> => ({
    name: 'error-tracking-assignment-rules-create',
    schema: ErrorTrackingAssignmentRulesCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingAssignmentRulesCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.assignee !== undefined) {
            body['assignee'] = params.assignee
        }
        if (params.order_key !== undefined) {
            body['order_key'] = params.order_key
        }
        const result = await context.api.request<Schemas.ErrorTrackingAssignmentRule>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/assignment_rules/`,
            body,
        })
        return result
    },
})

const ErrorTrackingAssignmentRulesListSchema = () => {
    const ErrorTrackingAssignmentRulesListQueryParams = orvalSchemas.ErrorTrackingAssignmentRulesListQueryParams()
    return ErrorTrackingAssignmentRulesListQueryParams
}

const errorTrackingAssignmentRulesList = (): ToolBase<
    ReturnType<typeof ErrorTrackingAssignmentRulesListSchema>,
    Schemas.PaginatedErrorTrackingAssignmentRuleList
> => ({
    name: 'error-tracking-assignment-rules-list',
    schema: ErrorTrackingAssignmentRulesListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingAssignmentRulesListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedErrorTrackingAssignmentRuleList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/assignment_rules/`,
            query: {
                limit: params.limit,
                offset: params.offset,
            },
        })
        return result
    },
})

const ErrorTrackingBypassRulesCreateSchema = () => {
    const ErrorTrackingBypassRulesCreateBody = orvalSchemas.ErrorTrackingBypassRulesCreateBody()
    return ErrorTrackingBypassRulesCreateBody
}

const errorTrackingBypassRulesCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingBypassRulesCreateSchema>,
    Schemas.ErrorTrackingBypassRule
> => ({
    name: 'error-tracking-bypass-rules-create',
    schema: ErrorTrackingBypassRulesCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingBypassRulesCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        const result = await context.api.request<Schemas.ErrorTrackingBypassRule>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/bypass_rules/`,
            body,
        })
        return result
    },
})

const ErrorTrackingBypassRulesListSchema = () => {
    const ErrorTrackingBypassRulesListQueryParams = orvalSchemas.ErrorTrackingBypassRulesListQueryParams()
    return ErrorTrackingBypassRulesListQueryParams
}

const errorTrackingBypassRulesList = (): ToolBase<
    ReturnType<typeof ErrorTrackingBypassRulesListSchema>,
    Schemas.PaginatedErrorTrackingBypassRuleList
> => ({
    name: 'error-tracking-bypass-rules-list',
    schema: ErrorTrackingBypassRulesListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingBypassRulesListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedErrorTrackingBypassRuleList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/bypass_rules/`,
            query: {
                limit: params.limit,
                offset: params.offset,
            },
        })
        return result
    },
})

const ErrorTrackingBypassRulesUpdateSchema = () => {
    const ErrorTrackingBypassRulesUpdateBody = orvalSchemas.ErrorTrackingBypassRulesUpdateBody()
    const ErrorTrackingBypassRulesUpdateParams = orvalSchemas.ErrorTrackingBypassRulesUpdateParams()
    return ErrorTrackingBypassRulesUpdateParams.omit({ project_id: true }).extend(
        ErrorTrackingBypassRulesUpdateBody.shape
    )
}

const errorTrackingBypassRulesUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingBypassRulesUpdateSchema>,
    unknown
> => ({
    name: 'error-tracking-bypass-rules-update',
    schema: ErrorTrackingBypassRulesUpdateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingBypassRulesUpdateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        const result = await context.api.request<unknown>({
            method: 'PUT',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/bypass_rules/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

const ErrorTrackingExternalReferencesCreateSchema = () => {
    const ErrorTrackingExternalReferencesCreateBody = orvalSchemas.ErrorTrackingExternalReferencesCreateBody()
    return ErrorTrackingExternalReferencesCreateBody
}

const errorTrackingExternalReferencesCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingExternalReferencesCreateSchema>,
    Schemas.ErrorTrackingExternalReferenceResult
> => ({
    name: 'error-tracking-external-references-create',
    schema: ErrorTrackingExternalReferencesCreateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ErrorTrackingExternalReferencesCreateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.integration_id !== undefined) {
            body['integration_id'] = params.integration_id
        }
        if (params.config !== undefined) {
            body['config'] = params.config
        }
        if (params.issue !== undefined) {
            body['issue'] = params.issue
        }
        const result = await context.api.request<Schemas.ErrorTrackingExternalReferenceResult>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/external_references/`,
            body,
        })
        return result
    },
})

const ErrorTrackingGroupingRulesCreateSchema = () => {
    const ErrorTrackingGroupingRulesCreateBody = orvalSchemas.ErrorTrackingGroupingRulesCreateBody()
    return ErrorTrackingGroupingRulesCreateBody
}

const errorTrackingGroupingRulesCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingGroupingRulesCreateSchema>,
    Schemas.ErrorTrackingGroupingRule
> => ({
    name: 'error-tracking-grouping-rules-create',
    schema: ErrorTrackingGroupingRulesCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingGroupingRulesCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.assignee !== undefined) {
            body['assignee'] = params.assignee
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        const result = await context.api.request<Schemas.ErrorTrackingGroupingRule>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/grouping_rules/`,
            body,
        })
        return result
    },
})

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

const errorTrackingGroupingRulesList = (): ToolBase<
    ReturnType<typeof ErrorTrackingGroupingRulesListSchema>,
    Schemas.ErrorTrackingGroupingRuleListResponse
> => ({
    name: 'error-tracking-grouping-rules-list',
    schema: ErrorTrackingGroupingRulesListSchema(),
    handler: async (context: Context, _params: z.infer<ReturnType<typeof ErrorTrackingGroupingRulesListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ErrorTrackingGroupingRuleListResponse>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/grouping_rules/`,
        })
        return result
    },
})

const ErrorTrackingGroupingRulesUpdateSchema = () => {
    const ErrorTrackingGroupingRulesUpdateBody = orvalSchemas.ErrorTrackingGroupingRulesUpdateBody()
    const ErrorTrackingGroupingRulesUpdateParams = orvalSchemas.ErrorTrackingGroupingRulesUpdateParams()
    return ErrorTrackingGroupingRulesUpdateParams.omit({ project_id: true }).extend(
        ErrorTrackingGroupingRulesUpdateBody.shape
    )
}

const errorTrackingGroupingRulesUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingGroupingRulesUpdateSchema>,
    unknown
> => ({
    name: 'error-tracking-grouping-rules-update',
    schema: ErrorTrackingGroupingRulesUpdateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingGroupingRulesUpdateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        const result = await context.api.request<unknown>({
            method: 'PUT',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/grouping_rules/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

const ErrorTrackingIssuesAssignPartialUpdateSchema = () => {
    const ErrorTrackingIssuesAssignPartialUpdateBody = orvalSchemas.ErrorTrackingIssuesAssignPartialUpdateBody()
    const ErrorTrackingIssuesAssignPartialUpdateParams = orvalSchemas.ErrorTrackingIssuesAssignPartialUpdateParams()
    return ErrorTrackingIssuesAssignPartialUpdateParams.omit({ project_id: true }).extend(
        ErrorTrackingIssuesAssignPartialUpdateBody.shape
    )
}

const errorTrackingIssuesAssignPartialUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingIssuesAssignPartialUpdateSchema>,
    Schemas.ErrorTrackingIssueAssignResponse
> => ({
    name: 'error-tracking-issues-assign-partial-update',
    schema: ErrorTrackingIssuesAssignPartialUpdateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ErrorTrackingIssuesAssignPartialUpdateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.assignee !== undefined) {
            body['assignee'] = params.assignee
        }
        const result = await context.api.request<Schemas.ErrorTrackingIssueAssignResponse>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/issues/${encodeURIComponent(String(params.id))}/assign/`,
            body,
        })
        return result
    },
})

const ErrorTrackingIssuesMergeCreateSchema = () => {
    const ErrorTrackingIssuesMergeCreateBody = orvalSchemas.ErrorTrackingIssuesMergeCreateBody()
    const ErrorTrackingIssuesMergeCreateParams = orvalSchemas.ErrorTrackingIssuesMergeCreateParams()
    return ErrorTrackingIssuesMergeCreateParams.omit({ project_id: true }).extend(
        ErrorTrackingIssuesMergeCreateBody.shape
    )
}

const errorTrackingIssuesMergeCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingIssuesMergeCreateSchema>,
    Schemas.ErrorTrackingIssueMergeResponse
> => ({
    name: 'error-tracking-issues-merge-create',
    schema: ErrorTrackingIssuesMergeCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingIssuesMergeCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.ids !== undefined) {
            body['ids'] = params.ids
        }
        const result = await context.api.request<Schemas.ErrorTrackingIssueMergeResponse>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/issues/${encodeURIComponent(String(params.id))}/merge/`,
            body,
        })
        return result
    },
})

const ErrorTrackingIssuesPartialUpdateSchema = () => {
    const ErrorTrackingIssuesPartialUpdateBody = orvalSchemas.ErrorTrackingIssuesPartialUpdateBody()
    const ErrorTrackingIssuesPartialUpdateParams = orvalSchemas.ErrorTrackingIssuesPartialUpdateParams()
    return ErrorTrackingIssuesPartialUpdateParams.omit({ project_id: true }).extend(
        ErrorTrackingIssuesPartialUpdateBody.shape
    )
}

const errorTrackingIssuesPartialUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingIssuesPartialUpdateSchema>,
    WithPostHogUrl<Schemas.ErrorTrackingIssueRead>
> =>
    withUiApp('error-issue', {
        name: 'error-tracking-issues-partial-update',
        schema: ErrorTrackingIssuesPartialUpdateSchema(),
        handler: async (
            context: Context,
            params: z.infer<ReturnType<typeof ErrorTrackingIssuesPartialUpdateSchema>>
        ) => {
            const projectId = await context.stateManager.getProjectId()
            const body: Record<string, unknown> = {}
            if (params.status !== undefined) {
                body['status'] = params.status
            }
            if (params.severity !== undefined) {
                body['severity'] = params.severity
            }
            if (params.name !== undefined) {
                body['name'] = params.name
            }
            if (params.description !== undefined) {
                body['description'] = params.description
            }
            const result = await context.api.request<Schemas.ErrorTrackingIssueRead>({
                method: 'PATCH',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/issues/${encodeURIComponent(String(params.id))}/`,
                body,
            })
            return await withPostHogUrl(context, result, `/error-tracking/${result.id}`)
        },
    })

const ErrorTrackingIssuesSplitCreateSchema = () => {
    const ErrorTrackingIssuesSplitCreateBody = orvalSchemas.ErrorTrackingIssuesSplitCreateBody()
    const ErrorTrackingIssuesSplitCreateParams = orvalSchemas.ErrorTrackingIssuesSplitCreateParams()
    return ErrorTrackingIssuesSplitCreateParams.omit({ project_id: true }).extend(
        ErrorTrackingIssuesSplitCreateBody.shape
    )
}

const errorTrackingIssuesSplitCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingIssuesSplitCreateSchema>,
    Schemas.ErrorTrackingIssueSplitResponse
> => ({
    name: 'error-tracking-issues-split-create',
    schema: ErrorTrackingIssuesSplitCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingIssuesSplitCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.fingerprints !== undefined) {
            body['fingerprints'] = params.fingerprints
        }
        const result = await context.api.request<Schemas.ErrorTrackingIssueSplitResponse>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/issues/${encodeURIComponent(String(params.id))}/split/`,
            body,
        })
        return result
    },
})

const ErrorTrackingRecommendationsListSchema = () => {
    const ErrorTrackingRecommendationsListQueryParams = orvalSchemas.ErrorTrackingRecommendationsListQueryParams()
    return ErrorTrackingRecommendationsListQueryParams
}

const errorTrackingRecommendationsList = (): ToolBase<
    ReturnType<typeof ErrorTrackingRecommendationsListSchema>,
    Schemas.PaginatedErrorTrackingRecommendationList
> => ({
    name: 'error-tracking-recommendations-list',
    schema: ErrorTrackingRecommendationsListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingRecommendationsListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedErrorTrackingRecommendationList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/recommendations/`,
            query: {
                limit: params.limit,
                offset: params.offset,
                poll: params.poll,
            },
        })
        return result
    },
})

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

const errorTrackingSettingsGet = (): ToolBase<
    ReturnType<typeof ErrorTrackingSettingsGetSchema>,
    Schemas.ErrorTrackingSettings
> => ({
    name: 'error-tracking-settings-get',
    schema: ErrorTrackingSettingsGetSchema(),
    handler: async (context: Context, _params: z.infer<ReturnType<typeof ErrorTrackingSettingsGetSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ErrorTrackingSettings>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/settings/retrieve_settings/`,
        })
        return result
    },
})

const ErrorTrackingSettingsUpdateSchema = () => {
    const ErrorTrackingSettingsUpdateSettingsPartialUpdateBody =
        orvalSchemas.ErrorTrackingSettingsUpdateSettingsPartialUpdateBody()
    return ErrorTrackingSettingsUpdateSettingsPartialUpdateBody
}

const errorTrackingSettingsUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingSettingsUpdateSchema>,
    Schemas.ErrorTrackingSettings
> => ({
    name: 'error-tracking-settings-update',
    schema: ErrorTrackingSettingsUpdateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingSettingsUpdateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.adaptive_ingestion_enabled !== undefined) {
            body['adaptive_ingestion_enabled'] = params.adaptive_ingestion_enabled
        }
        if (params.project_rate_limit_value !== undefined) {
            body['project_rate_limit_value'] = params.project_rate_limit_value
        }
        if (params.project_rate_limit_bucket_size_minutes !== undefined) {
            body['project_rate_limit_bucket_size_minutes'] = params.project_rate_limit_bucket_size_minutes
        }
        if (params.per_issue_rate_limit_value !== undefined) {
            body['per_issue_rate_limit_value'] = params.per_issue_rate_limit_value
        }
        if (params.per_issue_rate_limit_bucket_size_minutes !== undefined) {
            body['per_issue_rate_limit_bucket_size_minutes'] = params.per_issue_rate_limit_bucket_size_minutes
        }
        if (params.ingestion_enabled !== undefined) {
            body['ingestion_enabled'] = params.ingestion_enabled
        }
        const result = await context.api.request<Schemas.ErrorTrackingSettings>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/settings/update_settings/`,
            body,
        })
        return result
    },
})

const ErrorTrackingSeverityRulesCreateSchema = () => {
    const ErrorTrackingSeverityRulesCreateBody = orvalSchemas.ErrorTrackingSeverityRulesCreateBody()
    return ErrorTrackingSeverityRulesCreateBody
}

const errorTrackingSeverityRulesCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingSeverityRulesCreateSchema>,
    Schemas.ErrorTrackingSeverityRule
> => ({
    name: 'error-tracking-severity-rules-create',
    schema: ErrorTrackingSeverityRulesCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingSeverityRulesCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.severity !== undefined) {
            body['severity'] = params.severity
        }
        if (params.order_key !== undefined) {
            body['order_key'] = params.order_key
        }
        const result = await context.api.request<Schemas.ErrorTrackingSeverityRule>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/severity_rules/`,
            body,
        })
        return result
    },
})

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

const errorTrackingSeverityRulesList = (): ToolBase<
    ReturnType<typeof ErrorTrackingSeverityRulesListSchema>,
    Schemas.ErrorTrackingSeverityRuleListResponse
> => ({
    name: 'error-tracking-severity-rules-list',
    schema: ErrorTrackingSeverityRulesListSchema(),
    handler: async (context: Context, _params: z.infer<ReturnType<typeof ErrorTrackingSeverityRulesListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ErrorTrackingSeverityRuleListResponse>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/severity_rules/`,
        })
        return result
    },
})

const ErrorTrackingSeverityRulesUpdateSchema = () => {
    const ErrorTrackingSeverityRulesUpdateBody = orvalSchemas.ErrorTrackingSeverityRulesUpdateBody()
    const ErrorTrackingSeverityRulesUpdateParams = orvalSchemas.ErrorTrackingSeverityRulesUpdateParams()
    return ErrorTrackingSeverityRulesUpdateParams.omit({ project_id: true }).extend(
        ErrorTrackingSeverityRulesUpdateBody.shape
    )
}

const errorTrackingSeverityRulesUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingSeverityRulesUpdateSchema>,
    unknown
> => ({
    name: 'error-tracking-severity-rules-update',
    schema: ErrorTrackingSeverityRulesUpdateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingSeverityRulesUpdateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.severity !== undefined) {
            body['severity'] = params.severity
        }
        const result = await context.api.request<unknown>({
            method: 'PUT',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/severity_rules/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

const ErrorTrackingSuppressionRulesCreateSchema = () => {
    const ErrorTrackingSuppressionRulesCreateBody = orvalSchemas.ErrorTrackingSuppressionRulesCreateBody()
    return ErrorTrackingSuppressionRulesCreateBody
}

const errorTrackingSuppressionRulesCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingSuppressionRulesCreateSchema>,
    Schemas.ErrorTrackingSuppressionRule
> => ({
    name: 'error-tracking-suppression-rules-create',
    schema: ErrorTrackingSuppressionRulesCreateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ErrorTrackingSuppressionRulesCreateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.sampling_rate !== undefined) {
            body['sampling_rate'] = params.sampling_rate
        }
        const result = await context.api.request<Schemas.ErrorTrackingSuppressionRule>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/suppression_rules/`,
            body,
        })
        return result
    },
})

const ErrorTrackingSuppressionRulesListSchema = () => {
    const ErrorTrackingSuppressionRulesListQueryParams = orvalSchemas.ErrorTrackingSuppressionRulesListQueryParams()
    return ErrorTrackingSuppressionRulesListQueryParams
}

const errorTrackingSuppressionRulesList = (): ToolBase<
    ReturnType<typeof ErrorTrackingSuppressionRulesListSchema>,
    Schemas.PaginatedErrorTrackingSuppressionRuleList
> => ({
    name: 'error-tracking-suppression-rules-list',
    schema: ErrorTrackingSuppressionRulesListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingSuppressionRulesListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedErrorTrackingSuppressionRuleList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/suppression_rules/`,
            query: {
                limit: params.limit,
                offset: params.offset,
            },
        })
        return result
    },
})

const ErrorTrackingSuppressionRulesUpdateSchema = () => {
    const ErrorTrackingSuppressionRulesUpdateBody = orvalSchemas.ErrorTrackingSuppressionRulesUpdateBody()
    const ErrorTrackingSuppressionRulesUpdateParams = orvalSchemas.ErrorTrackingSuppressionRulesUpdateParams()
    return ErrorTrackingSuppressionRulesUpdateParams.omit({ project_id: true }).extend(
        ErrorTrackingSuppressionRulesUpdateBody.shape
    )
}

const errorTrackingSuppressionRulesUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingSuppressionRulesUpdateSchema>,
    unknown
> => ({
    name: 'error-tracking-suppression-rules-update',
    schema: ErrorTrackingSuppressionRulesUpdateSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ErrorTrackingSuppressionRulesUpdateSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.sampling_rate !== undefined) {
            body['sampling_rate'] = params.sampling_rate
        }
        const result = await context.api.request<unknown>({
            method: 'PUT',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/suppression_rules/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

const ErrorTrackingSymbolSetsDownloadRetrieveSchema = () => {
    const ErrorTrackingSymbolSetsDownloadRetrieveParams = orvalSchemas.ErrorTrackingSymbolSetsDownloadRetrieveParams()
    return ErrorTrackingSymbolSetsDownloadRetrieveParams.omit({ project_id: true })
}

const errorTrackingSymbolSetsDownloadRetrieve = (): ToolBase<
    ReturnType<typeof ErrorTrackingSymbolSetsDownloadRetrieveSchema>,
    Schemas._SymbolSetDownloadResponse
> => ({
    name: 'error-tracking-symbol-sets-download-retrieve',
    schema: ErrorTrackingSymbolSetsDownloadRetrieveSchema(),
    handler: async (
        context: Context,
        params: z.infer<ReturnType<typeof ErrorTrackingSymbolSetsDownloadRetrieveSchema>>
    ) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas._SymbolSetDownloadResponse>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/symbol_sets/${encodeURIComponent(String(params.id))}/download/`,
        })
        return result
    },
})

const ErrorTrackingSymbolSetsListSchema = () => {
    const ErrorTrackingSymbolSetsListQueryParams = orvalSchemas.ErrorTrackingSymbolSetsListQueryParams()
    return ErrorTrackingSymbolSetsListQueryParams
}

const errorTrackingSymbolSetsList = (): ToolBase<
    ReturnType<typeof ErrorTrackingSymbolSetsListSchema>,
    WithPostHogUrl<Schemas.PaginatedErrorTrackingSymbolSetList>
> => ({
    name: 'error-tracking-symbol-sets-list',
    schema: ErrorTrackingSymbolSetsListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingSymbolSetsListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedErrorTrackingSymbolSetList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/symbol_sets/`,
            query: {
                limit: params.limit,
                offset: params.offset,
                order_by: params.order_by,
                ref: params.ref,
                search: params.search,
                status: params.status,
            },
        })
        const filtered = {
            ...result,
            results: (result.results ?? []).map((item: any) =>
                pickResponseFields(item, [
                    'id',
                    'ref',
                    'created_at',
                    'last_used',
                    'failure_reason',
                    'has_uploaded_file',
                    'release',
                ])
            ),
        } as typeof result
        return await withPostHogUrl(context, filtered, '/error-tracking')
    },
})

const ErrorTrackingSymbolSetsRetrieveSchema = () => {
    const ErrorTrackingSymbolSetsRetrieveParams = orvalSchemas.ErrorTrackingSymbolSetsRetrieveParams()
    return ErrorTrackingSymbolSetsRetrieveParams.omit({ project_id: true })
}

const errorTrackingSymbolSetsRetrieve = (): ToolBase<
    ReturnType<typeof ErrorTrackingSymbolSetsRetrieveSchema>,
    Schemas.ErrorTrackingSymbolSet
> => ({
    name: 'error-tracking-symbol-sets-retrieve',
    schema: ErrorTrackingSymbolSetsRetrieveSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingSymbolSetsRetrieveSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.ErrorTrackingSymbolSet>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/symbol_sets/${encodeURIComponent(String(params.id))}/`,
        })
        const filtered = pickResponseFields(result, [
            'id',
            'ref',
            'created_at',
            'last_used',
            'failure_reason',
            'has_uploaded_file',
            'release',
        ]) as typeof result
        return filtered
    },
})

const QueryErrorTrackingIssueSchema = () => {
    const ErrorTrackingQueryIssueCreateBody = orvalSchemas.ErrorTrackingQueryIssueCreateBody()
    return ErrorTrackingQueryIssueCreateBody
}

const queryErrorTrackingIssue = (): ToolBase<
    ReturnType<typeof QueryErrorTrackingIssueSchema>,
    WithPostHogUrl<Schemas.ErrorTrackingIssueDetail>
> =>
    withUiApp('error-issue', {
        name: 'query-error-tracking-issue',
        schema: QueryErrorTrackingIssueSchema(),
        handler: async (context: Context, params: z.infer<ReturnType<typeof QueryErrorTrackingIssueSchema>>) => {
            const projectId = await context.stateManager.getProjectId()
            const body: Record<string, unknown> = {}
            if (params.issueId !== undefined) {
                body['issueId'] = params.issueId
            }
            if (params.dateRange !== undefined) {
                body['dateRange'] = params.dateRange
            }
            if (params.filterTestAccounts !== undefined) {
                body['filterTestAccounts'] = params.filterTestAccounts
            }
            if (params.volumeResolution !== undefined) {
                body['volumeResolution'] = params.volumeResolution
            }
            if (params.includeSparkline !== undefined) {
                body['includeSparkline'] = params.includeSparkline
            }
            if (params.includeBreakdown !== undefined) {
                body['includeBreakdown'] = params.includeBreakdown
            }
            const result = await context.api.request<Schemas.ErrorTrackingIssueDetail>({
                method: 'POST',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/query/issue/`,
                body,
            })
            return await withPostHogUrl(context, result, `/error-tracking/${params.issueId}`)
        },
    })

const QueryErrorTrackingIssueEventsSchema = () => {
    const ErrorTrackingQueryIssueEventsCreateBody = orvalSchemas.ErrorTrackingQueryIssueEventsCreateBody()
    return ErrorTrackingQueryIssueEventsCreateBody
}

const queryErrorTrackingIssueEvents = (): ToolBase<
    ReturnType<typeof QueryErrorTrackingIssueEventsSchema>,
    WithPostHogUrl<Schemas.ErrorTrackingIssueEventsResponse>
> =>
    withUiApp('error-details', {
        name: 'query-error-tracking-issue-events',
        schema: QueryErrorTrackingIssueEventsSchema(),
        handler: async (context: Context, params: z.infer<ReturnType<typeof QueryErrorTrackingIssueEventsSchema>>) => {
            const projectId = await context.stateManager.getProjectId()
            const body: Record<string, unknown> = {}
            if (params.issueId !== undefined) {
                body['issueId'] = params.issueId
            }
            if (params.dateRange !== undefined) {
                body['dateRange'] = params.dateRange
            }
            if (params.filterTestAccounts !== undefined) {
                body['filterTestAccounts'] = params.filterTestAccounts
            }
            if (params.filterGroup !== undefined) {
                body['filterGroup'] = params.filterGroup
            }
            if (params.searchQuery !== undefined) {
                body['searchQuery'] = params.searchQuery
            }
            if (params.orderDirection !== undefined) {
                body['orderDirection'] = params.orderDirection
            }
            if (params.limit !== undefined) {
                body['limit'] = params.limit
            }
            if (params.offset !== undefined) {
                body['offset'] = params.offset
            }
            if (params.include !== undefined) {
                body['include'] = params.include
            }
            if (params.onlyAppFrames !== undefined) {
                body['onlyAppFrames'] = params.onlyAppFrames
            }
            const result = await context.api.request<Schemas.ErrorTrackingIssueEventsResponse>({
                method: 'POST',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/query/issue_events/`,
                body,
            })
            return await withPostHogUrl(context, result, `/error-tracking/${params.issueId}`)
        },
    })

const QueryErrorTrackingIssuesListSchema = () => {
    const ErrorTrackingQueryIssuesListCreateBody = orvalSchemas.ErrorTrackingQueryIssuesListCreateBody()
    return ErrorTrackingQueryIssuesListCreateBody
}

const queryErrorTrackingIssuesList = (): ToolBase<
    ReturnType<typeof QueryErrorTrackingIssuesListSchema>,
    WithPostHogUrl<Schemas.ErrorTrackingIssuesListResponse>
> =>
    withUiApp('error-issue-list', {
        name: 'query-error-tracking-issues-list',
        schema: QueryErrorTrackingIssuesListSchema(),
        handler: async (context: Context, params: z.infer<ReturnType<typeof QueryErrorTrackingIssuesListSchema>>) => {
            const projectId = await context.stateManager.getProjectId()
            const body: Record<string, unknown> = {}
            if (params.firstSeenAfter !== undefined) {
                body['firstSeenAfter'] = params.firstSeenAfter
            }
            if (params.dateRange !== undefined) {
                body['dateRange'] = params.dateRange
            }
            if (params.status !== undefined) {
                body['status'] = params.status
            }
            if (params.assignee !== undefined) {
                body['assignee'] = params.assignee
            }
            if (params.filterTestAccounts !== undefined) {
                body['filterTestAccounts'] = params.filterTestAccounts
            }
            if (params.searchQuery !== undefined) {
                body['searchQuery'] = params.searchQuery
            }
            if (params.filterGroup !== undefined) {
                body['filterGroup'] = params.filterGroup
            }
            if (params.orderBy !== undefined) {
                body['orderBy'] = params.orderBy
            }
            if (params.orderDirection !== undefined) {
                body['orderDirection'] = params.orderDirection
            }
            if (params.limit !== undefined) {
                body['limit'] = params.limit
            }
            if (params.offset !== undefined) {
                body['offset'] = params.offset
            }
            if (params.volumeResolution !== undefined) {
                body['volumeResolution'] = params.volumeResolution
            }
            if (params.library !== undefined) {
                body['library'] = params.library
            }
            if (params.release !== undefined) {
                body['release'] = params.release
            }
            if (params.fingerprint !== undefined) {
                body['fingerprint'] = params.fingerprint
            }
            if (params.user !== undefined) {
                body['user'] = params.user
            }
            if (params.personId !== undefined) {
                body['personId'] = params.personId
            }
            if (params.url !== undefined) {
                body['url'] = params.url
            }
            if (params.filePath !== undefined) {
                body['filePath'] = params.filePath
            }
            const result = await context.api.request<Schemas.ErrorTrackingIssuesListResponse>({
                method: 'POST',
                path: `/api/projects/${encodeURIComponent(String(projectId))}/error_tracking/query/issues/`,
                body,
            })
            const filtered = {
                ...result,
                results: (result.results ?? []).map((item: any) =>
                    pickResponseFields(item, [
                        'id',
                        'name',
                        'description',
                        'status',
                        'severity',
                        'first_seen',
                        'last_seen',
                        'library',
                        'source',
                        'assignee',
                        'aggregations',
                    ])
                ),
            } as typeof result
            return withTextProjection(
                await withPostHogUrl(
                    context,
                    {
                        ...filtered,
                        results: await Promise.all(
                            (filtered.results ?? []).map((item) =>
                                withPostHogUrl(context, item, `/error-tracking/${item.id}`)
                            )
                        ),
                    },
                    '/error-tracking'
                ),
                [
                    'id',
                    'name',
                    'status',
                    'severity',
                    'first_seen',
                    'last_seen',
                    'aggregations.occurrences',
                    'aggregations.users',
                    'aggregations.sessions',
                    '_posthogUrl',
                ]
            )
        },
    })

export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
    'error-tracking-assignment-rules-create': errorTrackingAssignmentRulesCreate,
    'error-tracking-assignment-rules-list': errorTrackingAssignmentRulesList,
    'error-tracking-bypass-rules-create': errorTrackingBypassRulesCreate,
    'error-tracking-bypass-rules-list': errorTrackingBypassRulesList,
    'error-tracking-bypass-rules-update': errorTrackingBypassRulesUpdate,
    'error-tracking-external-references-create': errorTrackingExternalReferencesCreate,
    'error-tracking-grouping-rules-create': errorTrackingGroupingRulesCreate,
    'error-tracking-grouping-rules-list': errorTrackingGroupingRulesList,
    'error-tracking-grouping-rules-update': errorTrackingGroupingRulesUpdate,
    'error-tracking-issues-assign-partial-update': errorTrackingIssuesAssignPartialUpdate,
    'error-tracking-issues-merge-create': errorTrackingIssuesMergeCreate,
    'error-tracking-issues-partial-update': errorTrackingIssuesPartialUpdate,
    'error-tracking-issues-split-create': errorTrackingIssuesSplitCreate,
    'error-tracking-recommendations-list': errorTrackingRecommendationsList,
    'error-tracking-settings-get': errorTrackingSettingsGet,
    'error-tracking-settings-update': errorTrackingSettingsUpdate,
    'error-tracking-severity-rules-create': errorTrackingSeverityRulesCreate,
    'error-tracking-severity-rules-list': errorTrackingSeverityRulesList,
    'error-tracking-severity-rules-update': errorTrackingSeverityRulesUpdate,
    'error-tracking-suppression-rules-create': errorTrackingSuppressionRulesCreate,
    'error-tracking-suppression-rules-list': errorTrackingSuppressionRulesList,
    'error-tracking-suppression-rules-update': errorTrackingSuppressionRulesUpdate,
    'error-tracking-symbol-sets-download-retrieve': errorTrackingSymbolSetsDownloadRetrieve,
    'error-tracking-symbol-sets-list': errorTrackingSymbolSetsList,
    'error-tracking-symbol-sets-retrieve': errorTrackingSymbolSetsRetrieve,
    'query-error-tracking-issue': queryErrorTrackingIssue,
    'query-error-tracking-issue-events': queryErrorTrackingIssueEvents,
    'query-error-tracking-issues-list': queryErrorTrackingIssuesList,
}