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.4 KB
Raw Blame
// AUTO-GENERATED from products/persons/mcp/tools.yaml + OpenAPI — do not edit
import { z } from 'zod'

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

const PersonsBulkDeleteSchema = () => {
    const PersonsBulkDeleteCreateBody = orvalSchemas.PersonsBulkDeleteCreateBody()
    return PersonsBulkDeleteCreateBody
}

const personsBulkDelete = (): ToolBase<ReturnType<typeof PersonsBulkDeleteSchema>, unknown> => ({
    name: 'persons-bulk-delete',
    schema: PersonsBulkDeleteSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsBulkDeleteSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.ids !== undefined) {
            body['ids'] = params.ids
        }
        if (params.distinct_ids !== undefined) {
            body['distinct_ids'] = params.distinct_ids
        }
        if (params.delete_events !== undefined) {
            body['delete_events'] = params.delete_events
        }
        if (params.delete_recordings !== undefined) {
            body['delete_recordings'] = params.delete_recordings
        }
        if (params.keep_person !== undefined) {
            body['keep_person'] = params.keep_person
        }
        const result = await context.api.request<unknown>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/bulk_delete/`,
            body,
        })
        return result
    },
})

const PersonsCohortsRetrieveSchema = () => {
    const PersonsCohortsRetrieveQueryParams = orvalSchemas.PersonsCohortsRetrieveQueryParams()
    return PersonsCohortsRetrieveQueryParams.omit({ format: true })
}

const personsCohortsRetrieve = (): ToolBase<
    ReturnType<typeof PersonsCohortsRetrieveSchema>,
    Schemas.PersonCohortsResponse
> => ({
    name: 'persons-cohorts-retrieve',
    schema: PersonsCohortsRetrieveSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsCohortsRetrieveSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PersonCohortsResponse>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/cohorts/`,
            query: {
                person_id: params.person_id,
            },
        })
        return result
    },
})

const PersonsListSchema = () => {
    const PersonsListQueryParams = orvalSchemas.PersonsListQueryParams()
    return PersonsListQueryParams.omit({ format: true, include_matched_fields: true, properties: true }).extend({
        limit: z.preprocess(castStringToInt, PersonsListQueryParams.shape['limit']).optional(),
        offset: z.preprocess(castStringToInt, PersonsListQueryParams.shape['offset']).optional(),
    })
}

const personsList = (): ToolBase<
    ReturnType<typeof PersonsListSchema>,
    WithPostHogUrl<Schemas.PaginatedPersonListRecordList>
> => ({
    name: 'persons-list',
    schema: PersonsListSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsListSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PaginatedPersonListRecordList>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/`,
            query: {
                client_query_id: params.client_query_id,
                distinct_id: params.distinct_id,
                email: params.email,
                limit: params.limit,
                offset: params.offset,
                search: params.search,
            },
        })
        const filtered = {
            ...result,
            results: (result.results ?? []).map((item: any) =>
                pickResponseFields(item, [
                    'id',
                    'uuid',
                    'name',
                    'distinct_ids',
                    'properties.email',
                    'properties.$email',
                    'properties.$geoip_country_code',
                    'created_at',
                    'last_seen_at',
                ])
            ),
        } as typeof result
        return await withPostHogUrl(context, filtered, '/persons')
    },
})

const PersonsPropertyDeleteSchema = () => {
    const PersonsDeletePropertyCreateBody = orvalSchemas.PersonsDeletePropertyCreateBody()
    const PersonsDeletePropertyCreateParams = orvalSchemas.PersonsDeletePropertyCreateParams()
    return PersonsDeletePropertyCreateParams.omit({ project_id: true })
        .extend(PersonsDeletePropertyCreateBody.shape)
        .omit({ $unset: true })
        .extend({ unset: PersonsDeletePropertyCreateBody.shape['$unset'] })
}

const personsPropertyDelete = (): ToolBase<ReturnType<typeof PersonsPropertyDeleteSchema>, unknown> => ({
    name: 'persons-property-delete',
    schema: PersonsPropertyDeleteSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsPropertyDeleteSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.unset !== undefined) {
            body['$unset'] = params.unset
        }
        const result = await context.api.request<unknown>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/${encodeURIComponent(String(params.id))}/delete_property/`,
            body,
        })
        return result
    },
})

const PersonsPropertySetSchema = () => {
    const PersonsUpdatePropertyCreateBody = orvalSchemas.PersonsUpdatePropertyCreateBody()
    const PersonsUpdatePropertyCreateParams = orvalSchemas.PersonsUpdatePropertyCreateParams()
    return PersonsUpdatePropertyCreateParams.omit({ project_id: true }).extend(PersonsUpdatePropertyCreateBody.shape)
}

const personsPropertySet = (): ToolBase<ReturnType<typeof PersonsPropertySetSchema>, unknown> => ({
    name: 'persons-property-set',
    schema: PersonsPropertySetSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsPropertySetSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const body: Record<string, unknown> = {}
        if (params.key !== undefined) {
            body['key'] = params.key
        }
        if (params.value !== undefined) {
            body['value'] = params.value
        }
        if (params.properties !== undefined) {
            body['properties'] = params.properties
        }
        const result = await context.api.request<unknown>({
            method: 'POST',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/${encodeURIComponent(String(params.id))}/update_property/`,
            body,
        })
        return result
    },
})

const PersonsRetrieveSchema = () => {
    const PersonsRetrieveParams = orvalSchemas.PersonsRetrieveParams()
    return PersonsRetrieveParams.omit({ project_id: true })
}

const personsRetrieve = (): ToolBase<
    ReturnType<typeof PersonsRetrieveSchema>,
    WithPostHogUrl<Schemas.PersonRecord>
> => ({
    name: 'persons-retrieve',
    schema: PersonsRetrieveSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsRetrieveSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<Schemas.PersonRecord>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/${encodeURIComponent(String(params.id))}/`,
        })
        const filtered = pickResponseFields(result, [
            'id',
            'uuid',
            'name',
            'properties',
            'distinct_ids',
            'created_at',
            'last_seen_at',
        ]) as typeof result
        return await withPostHogUrl(context, filtered, `/persons/${filtered.uuid}`)
    },
})

const PersonsValuesRetrieveSchema = () => {
    const PersonsValuesRetrieveQueryParams = orvalSchemas.PersonsValuesRetrieveQueryParams()
    return PersonsValuesRetrieveQueryParams.omit({ format: true })
}

const personsValuesRetrieve = (): ToolBase<ReturnType<typeof PersonsValuesRetrieveSchema>, unknown> => ({
    name: 'persons-values-retrieve',
    schema: PersonsValuesRetrieveSchema(),
    handler: async (context: Context, params: z.infer<ReturnType<typeof PersonsValuesRetrieveSchema>>) => {
        const projectId = await context.stateManager.getProjectId()
        const result = await context.api.request<unknown>({
            method: 'GET',
            path: `/api/projects/${encodeURIComponent(String(projectId))}/persons/values/`,
            query: {
                key: params.key,
                value: params.value,
            },
        })
        return result
    },
})

export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
    'persons-bulk-delete': personsBulkDelete,
    'persons-cohorts-retrieve': personsCohortsRetrieve,
    'persons-list': personsList,
    'persons-property-delete': personsPropertyDelete,
    'persons-property-set': personsPropertySet,
    'persons-retrieve': personsRetrieve,
    'persons-values-retrieve': personsValuesRetrieve,
}