: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
// 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,
}