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.

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

import type { Schemas } from '@/api/generated'
import * as orvalSchemas from '@/generated/error_tracking_alerts/api'
import { withPostHogUrl, pickResponseFields, type WithPostHogUrl } from '@/tools/tool-utils'
import type { Context, ToolBase, ZodObjectAny } from '@/tools/types'

const ErrorTrackingAlertsCreateSchema = () => {
    const HogFunctionsCreateBody = orvalSchemas.HogFunctionsCreateBody()
    return HogFunctionsCreateBody.extend({
        type: HogFunctionsCreateBody.shape['type'].describe(
            'Must be `internal_destination` for an error tracking alert. Other values create non-alert HogFunctions and should be created via `cdp-functions-create` instead.'
        ),
        template_id: HogFunctionsCreateBody.shape['template_id'].describe(
            'Integration template — one of `template-slack`, `template-webhook`, `template-discord`, `template-microsoft-teams`, `template-linear`, `template-github`, `template-gitlab`.'
        ),
        enabled: HogFunctionsCreateBody.shape['enabled'].describe('Whether the alert is active. Defaults to true.'),
    })
}

const errorTrackingAlertsCreate = (): ToolBase<
    ReturnType<typeof ErrorTrackingAlertsCreateSchema>,
    Schemas.HogFunction
> => ({
    name: 'error-tracking-alerts-create',
    schema: ErrorTrackingAlertsCreateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingAlertsCreateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.type !== undefined) {
            body['type'] = params.type
        }
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        if (params.enabled !== undefined) {
            body['enabled'] = params.enabled
        }
        if (params.hog !== undefined) {
            body['hog'] = params.hog
        }
        if (params.inputs_schema !== undefined) {
            body['inputs_schema'] = params.inputs_schema
        }
        if (params.inputs !== undefined) {
            body['inputs'] = params.inputs
        }
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.masking !== undefined) {
            body['masking'] = params.masking
        }
        if (params.mappings !== undefined) {
            body['mappings'] = params.mappings
        }
        if (params.icon_url !== undefined) {
            body['icon_url'] = params.icon_url
        }
        if (params.template_id !== undefined) {
            body['template_id'] = params.template_id
        }
        if (params.execution_order !== undefined) {
            body['execution_order'] = params.execution_order
        }
        const result = await context.api.request<Schemas.HogFunction>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_functions/`,
            body,
        })
        return result
    },
})

const ErrorTrackingAlertsDeleteSchema = () => {
    const HogFunctionsDestroyParams = orvalSchemas.HogFunctionsDestroyParams()
    return HogFunctionsDestroyParams.omit({ project_id: true })
}

const errorTrackingAlertsDelete = (): ToolBase<
    ReturnType<typeof ErrorTrackingAlertsDeleteSchema>,
    Schemas.HogFunction
> => ({
    name: 'error-tracking-alerts-delete',
    schema: ErrorTrackingAlertsDeleteSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingAlertsDeleteSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.HogFunction>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_functions/${encodeURIComponent(String(params.id))}/`,
            body: { deleted: true },
        })
        return result
    },
})

const ErrorTrackingAlertsListSchema = () => {
    const HogFunctionsListQueryParams = orvalSchemas.HogFunctionsListQueryParams()
    return HogFunctionsListQueryParams
}

const errorTrackingAlertsList = (): ToolBase<
    ReturnType<typeof ErrorTrackingAlertsListSchema>,
    WithPostHogUrl<Schemas.PaginatedHogFunctionMinimalList>
> => ({
    name: 'error-tracking-alerts-list',
    schema: ErrorTrackingAlertsListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingAlertsListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedHogFunctionMinimalList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_functions/`,
            query: {
                created_at: params.created_at,
                created_by: params.created_by,
                enabled: params.enabled,
                id: params.id,
                limit: params.limit,
                offset: params.offset,
                type: Array.isArray(params.type) ? params.type.join(',') || undefined : params.type,
                updated_at: params.updated_at,
            },
        })
        const filtered = {
            ...result,
            results: (result.results ?? []).map((item: any) =>
                pickResponseFields(item, [
                    'id',
                    'type',
                    'name',
                    'description',
                    'enabled',
                    'icon_url',
                    'template.id',
                    'status',
                    'created_at',
                    'updated_at',
                    'created_by',
                    'filters',
                ])
            ),
        } as typeof result
        return await withPostHogUrl(context, filtered, '/error-tracking')
    },
})

const ErrorTrackingAlertsPartialUpdateSchema = () => {
    const HogFunctionsPartialUpdateBody = orvalSchemas.HogFunctionsPartialUpdateBody()
    const HogFunctionsPartialUpdateParams = orvalSchemas.HogFunctionsPartialUpdateParams()
    return HogFunctionsPartialUpdateParams.omit({ project_id: true })
        .extend(HogFunctionsPartialUpdateBody.shape)
        .extend({
            enabled: HogFunctionsPartialUpdateBody.shape['enabled'].describe(
                'Set to true to activate the alert or false to silence it without deleting.'
            ),
        })
}

const errorTrackingAlertsPartialUpdate = (): ToolBase<
    ReturnType<typeof ErrorTrackingAlertsPartialUpdateSchema>,
    Schemas.HogFunction
> => ({
    name: 'error-tracking-alerts-partial-update',
    schema: ErrorTrackingAlertsPartialUpdateSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof ErrorTrackingAlertsPartialUpdateSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.type !== undefined) {
            body['type'] = params.type
        }
        if (params.name !== undefined) {
            body['name'] = params.name
        }
        if (params.description !== undefined) {
            body['description'] = params.description
        }
        if (params.enabled !== undefined) {
            body['enabled'] = params.enabled
        }
        if (params.hog !== undefined) {
            body['hog'] = params.hog
        }
        if (params.inputs_schema !== undefined) {
            body['inputs_schema'] = params.inputs_schema
        }
        if (params.inputs !== undefined) {
            body['inputs'] = params.inputs
        }
        if (params.filters !== undefined) {
            body['filters'] = params.filters
        }
        if (params.masking !== undefined) {
            body['masking'] = params.masking
        }
        if (params.mappings !== undefined) {
            body['mappings'] = params.mappings
        }
        if (params.icon_url !== undefined) {
            body['icon_url'] = params.icon_url
        }
        if (params.template_id !== undefined) {
            body['template_id'] = params.template_id
        }
        if (params.execution_order !== undefined) {
            body['execution_order'] = params.execution_order
        }
        if (params.base_updated_at !== undefined) {
            body['base_updated_at'] = params.base_updated_at
        }
        const result = await context.api.request<Schemas.HogFunction>({
            method: 'PATCH',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_functions/${encodeURIComponent(String(params.id))}/`,
            body,
        })
        return result
    },
})

export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
    'error-tracking-alerts-create': errorTrackingAlertsCreate,
    'error-tracking-alerts-delete': errorTrackingAlertsDelete,
    'error-tracking-alerts-list': errorTrackingAlertsList,
    'error-tracking-alerts-partial-update': errorTrackingAlertsPartialUpdate,
}