: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/workflows/mcp/tools.yaml + OpenAPI — do not edit
import { z } from 'zod'
import type { Schemas } from '@/api/generated'
import * as orvalSchemas from '@/generated/workflows/api'
import { withUiApp } from '@/resources/ui-apps'
import { WorkflowActionEmailPatchSchema, WorkflowGraphPatchSchema } from '@/schema/tool-inputs'
import { transformRequestBody, withToolHooks } from '@/tools/tool-hooks'
import { withPostHogUrl, omitResponseFields, pickResponseFields, type WithPostHogUrl } from '@/tools/tool-utils'
import type { Context, ToolBase, ZodObjectAny } from '@/tools/types'
import hooks_workflowsCreate from '@/tools/workflows/broadcastLinkHooks'
import hooks_workflowsGet from '@/tools/workflows/broadcastLinkHooks'
import hooks_workflowsUpdate from '@/tools/workflows/broadcastLinkHooks'
import hooks_workflowsDataSuggestionsCreate from '@/tools/workflows/dataSuggestionCreateHooks'
const BroadcastsCreateSchema = () => {
const HogFlowsCreateBody = orvalSchemas.HogFlowsCreateBody()
return HogFlowsCreateBody
}
const broadcastsCreate = (): ToolBase<ReturnType<typeof BroadcastsCreateSchema>, WithPostHogUrl<Schemas.HogFlow>> => ({
name: 'broadcasts-create',
schema: BroadcastsCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof BroadcastsCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.description !== undefined) {
body['description'] = params.description
}
if (params.tags !== undefined) {
body['tags'] = params.tags
}
if (params.status !== undefined) {
body['status'] = params.status
}
if (params.origin_product !== undefined) {
body['origin_product'] = params.origin_product
}
if (params.source_record !== undefined) {
body['source_record'] = params.source_record
}
if (params.trigger_masking !== undefined) {
body['trigger_masking'] = params.trigger_masking
}
if (params.conversion !== undefined) {
body['conversion'] = params.conversion
}
if (params.exit_condition !== undefined) {
body['exit_condition'] = params.exit_condition
}
if (params.email_sending_rate_limit !== undefined) {
body['email_sending_rate_limit'] = params.email_sending_rate_limit
}
if (params.edges !== undefined) {
body['edges'] = params.edges
}
if (params.actions !== undefined) {
body['actions'] = params.actions
}
if (params.variables !== undefined) {
body['variables'] = params.variables
}
body['origin_product'] = 'broadcasts'
const result = await context.api.request<Schemas.HogFlow>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/`,
body,
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return await withPostHogUrl(context, filtered, `/broadcasts/${filtered.id}`)
},
})
const WorkflowsConvertToBroadcastSchema = () => {
const HogFlowsConvertToBroadcastParams = orvalSchemas.HogFlowsConvertToBroadcastParams()
return HogFlowsConvertToBroadcastParams.omit({ project_id: true })
}
const workflowsConvertToBroadcast = (): ToolBase<
ReturnType<typeof WorkflowsConvertToBroadcastSchema>,
WithPostHogUrl<Schemas.HogFlowConvertedToBroadcast>
> => ({
name: 'workflows-convert-to-broadcast',
schema: WorkflowsConvertToBroadcastSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsConvertToBroadcastSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogFlowConvertedToBroadcast>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/convert_to_broadcast/`,
})
return await withPostHogUrl(context, result, `/broadcasts/${result.id}`)
},
})
const WorkflowsCreateSchema = () => {
const HogFlowsCreateBody = orvalSchemas.HogFlowsCreateBody()
return HogFlowsCreateBody
}
const workflowsCreate = (): ToolBase<ReturnType<typeof WorkflowsCreateSchema>, WithPostHogUrl<Schemas.HogFlow>> =>
withUiApp('workflow', {
name: 'workflows-create',
schema: WorkflowsCreateSchema(),
handler: withToolHooks(
hooks_workflowsCreate,
async (context: Context, params: z.infer<ReturnType<typeof WorkflowsCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.description !== undefined) {
body['description'] = params.description
}
if (params.tags !== undefined) {
body['tags'] = params.tags
}
if (params.status !== undefined) {
body['status'] = params.status
}
if (params.origin_product !== undefined) {
body['origin_product'] = params.origin_product
}
if (params.source_record !== undefined) {
body['source_record'] = params.source_record
}
if (params.trigger_masking !== undefined) {
body['trigger_masking'] = params.trigger_masking
}
if (params.conversion !== undefined) {
body['conversion'] = params.conversion
}
if (params.exit_condition !== undefined) {
body['exit_condition'] = params.exit_condition
}
if (params.email_sending_rate_limit !== undefined) {
body['email_sending_rate_limit'] = params.email_sending_rate_limit
}
if (params.edges !== undefined) {
body['edges'] = params.edges
}
if (params.actions !== undefined) {
body['actions'] = params.actions
}
if (params.variables !== undefined) {
body['variables'] = params.variables
}
const result = await context.api.request<Schemas.HogFlow>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/`,
body: await transformRequestBody(hooks_workflowsCreate, context, params, body),
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return await withPostHogUrl(context, filtered, `/workflows/${filtered.id}/workflow`)
}
),
})
const WorkflowsDataSuggestionsCreateSchema = () => {
const WorkflowDataSuggestionsBuildBody = orvalSchemas.WorkflowDataSuggestionsBuildBody()
return WorkflowDataSuggestionsBuildBody
}
const workflowsDataSuggestionsCreate = (): ToolBase<
ReturnType<typeof WorkflowsDataSuggestionsCreateSchema>,
Schemas.DataSuggestionBuildResponse
> =>
withUiApp('workflow-data-suggestions', {
name: 'workflows-data-suggestions-create',
schema: WorkflowsDataSuggestionsCreateSchema(),
handler: withToolHooks(
hooks_workflowsDataSuggestionsCreate,
async (context: Context, params: z.infer<ReturnType<typeof WorkflowsDataSuggestionsCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.suggestion_id !== undefined) {
body['suggestion_id'] = params.suggestion_id
}
if (params.retry !== undefined) {
body['retry'] = params.retry
}
body['save_draft'] = true
const result = await context.api.request<Schemas.DataSuggestionBuildResponse>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_data_suggestions/build/`,
body: await transformRequestBody(hooks_workflowsDataSuggestionsCreate, context, params, body),
})
const filtered = pickResponseFields(result, [
'status',
'workflow_id',
'missing_inputs',
'uses_saved_template',
]) as typeof result
return filtered
}
),
})
const WorkflowsDataSuggestionsGetSchema = () => z.object({})
const workflowsDataSuggestionsGet = (): ToolBase<
ReturnType<typeof WorkflowsDataSuggestionsGetSchema>,
Schemas.DataSuggestionsResponse
> =>
withUiApp('workflow-data-suggestions', {
name: 'workflows-data-suggestions-get',
schema: WorkflowsDataSuggestionsGetSchema(),
handler: async (context: Context, _params: z.infer<ReturnType<typeof WorkflowsDataSuggestionsGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.DataSuggestionsResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_data_suggestions/current/`,
})
const filtered = pickResponseFields(result, [
'status',
'suggestions.*.id',
'suggestions.*.name',
'suggestions.*.description',
'suggestions.*.reason',
'suggestions.*.trigger_event',
'suggestions.*.weekly_count',
'email_sender_ready',
]) as typeof result
return filtered
},
})
const WorkflowsDataSuggestionsListSchema = () => {
const WorkflowDataSuggestionsGenerateBody = orvalSchemas.WorkflowDataSuggestionsGenerateBody()
return WorkflowDataSuggestionsGenerateBody
}
const workflowsDataSuggestionsList = (): ToolBase<
ReturnType<typeof WorkflowsDataSuggestionsListSchema>,
Schemas.DataSuggestionsResponse
> =>
withUiApp('workflow-data-suggestions', {
name: 'workflows-data-suggestions-list',
schema: WorkflowsDataSuggestionsListSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsDataSuggestionsListSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.refresh !== undefined) {
body['refresh'] = params.refresh
}
const result = await context.api.request<Schemas.DataSuggestionsResponse>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_data_suggestions/generate/`,
body,
})
const filtered = pickResponseFields(result, [
'status',
'suggestions.*.id',
'suggestions.*.name',
'suggestions.*.description',
'suggestions.*.reason',
'suggestions.*.trigger_event',
'suggestions.*.weekly_count',
'email_sender_ready',
]) as typeof result
return filtered
},
})
const WorkflowsDiscardDraftSchema = () => {
const HogFlowsDiscardDraftCreateParams = orvalSchemas.HogFlowsDiscardDraftCreateParams()
return HogFlowsDiscardDraftCreateParams.omit({ project_id: true })
}
const workflowsDiscardDraft = (): ToolBase<ReturnType<typeof WorkflowsDiscardDraftSchema>, Schemas.HogFlow> =>
withUiApp('workflow', {
name: 'workflows-discard-draft',
schema: WorkflowsDiscardDraftSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsDiscardDraftSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogFlow>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/discard_draft/`,
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return filtered
},
})
const WorkflowsEmailDraftsCreateSchema = () => {
const WorkflowDataSuggestionsBuildForEventsBody = orvalSchemas.WorkflowDataSuggestionsBuildForEventsBody()
return WorkflowDataSuggestionsBuildForEventsBody
}
const workflowsEmailDraftsCreate = (): ToolBase<
ReturnType<typeof WorkflowsEmailDraftsCreateSchema>,
Schemas.EventWorkflowsBuildResponse
> => ({
name: 'workflows-email-drafts-create',
schema: WorkflowsEmailDraftsCreateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsEmailDraftsCreateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.events !== undefined) {
body['events'] = params.events
}
if (params.retry !== undefined) {
body['retry'] = params.retry
}
const result = await context.api.request<Schemas.EventWorkflowsBuildResponse>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_data_suggestions/build_for_events/`,
body,
})
return result
},
})
const WorkflowsGetSchema = () => {
const HogFlowsRetrieveParams = orvalSchemas.HogFlowsRetrieveParams()
return HogFlowsRetrieveParams.omit({ project_id: true })
}
const workflowsGet = (): ToolBase<ReturnType<typeof WorkflowsGetSchema>, WithPostHogUrl<Schemas.HogFlow>> =>
withUiApp('workflow', {
name: 'workflows-get',
schema: WorkflowsGetSchema(),
handler: withToolHooks(
hooks_workflowsGet,
async (context: Context, params: z.infer<ReturnType<typeof WorkflowsGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogFlow>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/`,
})
return await withPostHogUrl(context, result, `/workflows/${result.id}/workflow`)
}
),
})
const WorkflowsGetInvocationSchema = () => {
const HogFlowsInvocationResultRetrieveParams = orvalSchemas.HogFlowsInvocationResultRetrieveParams()
return HogFlowsInvocationResultRetrieveParams.omit({ project_id: true })
}
const workflowsGetInvocation = (): ToolBase<
ReturnType<typeof WorkflowsGetInvocationSchema>,
Schemas.HogInvocationResultDetail
> => ({
name: 'workflows-get-invocation',
schema: WorkflowsGetInvocationSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsGetInvocationSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogInvocationResultDetail>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/invocation_results/${encodeURIComponent(String(params.invocation_id))}/`,
})
return result
},
})
const WorkflowsGetRevisionSchema = () => {
const HogFlowsRevisionsRetrieveParams = orvalSchemas.HogFlowsRevisionsRetrieveParams()
return HogFlowsRevisionsRetrieveParams.omit({ project_id: true })
}
const workflowsGetRevision = (): ToolBase<ReturnType<typeof WorkflowsGetRevisionSchema>, Schemas.HogFlowRevision> => ({
name: 'workflows-get-revision',
schema: WorkflowsGetRevisionSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsGetRevisionSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogFlowRevision>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/revisions/${encodeURIComponent(String(params.version))}/`,
})
return result
},
})
const WorkflowsGlobalStatsSchema = () => {
const HogFlowsMetricsGlobalRetrieveQueryParams = orvalSchemas.HogFlowsMetricsGlobalRetrieveQueryParams()
return HogFlowsMetricsGlobalRetrieveQueryParams
}
const workflowsGlobalStats = (): ToolBase<
ReturnType<typeof WorkflowsGlobalStatsSchema>,
WithPostHogUrl<Schemas.WorkflowStatsRow[]>
> => ({
name: 'workflows-global-stats',
schema: WorkflowsGlobalStatsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsGlobalStatsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.WorkflowStatsRow[]>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/metrics/global/`,
query: {
after: params.after,
before: params.before,
},
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsImportCustomerioSchema = () => {
const WorkflowImportsCreateBody = orvalSchemas.WorkflowImportsCreateBody()
return WorkflowImportsCreateBody
}
const workflowsImportCustomerio = (): ToolBase<
ReturnType<typeof WorkflowsImportCustomerioSchema>,
Schemas.WorkflowImportResponse
> => ({
name: 'workflows-import-customerio',
schema: WorkflowsImportCustomerioSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsImportCustomerioSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.source !== undefined) {
body['source'] = params.source
}
if (params.campaigns !== undefined) {
body['campaigns'] = params.campaigns
}
if (params.snippets !== undefined) {
body['snippets'] = params.snippets
}
if (params.segment_cohorts !== undefined) {
body['segment_cohorts'] = params.segment_cohorts
}
if (params.layouts !== undefined) {
body['layouts'] = params.layouts
}
if (params.sender_identities !== undefined) {
body['sender_identities'] = params.sender_identities
}
if (params.segments !== undefined) {
body['segments'] = params.segments
}
if (params.dry_run !== undefined) {
body['dry_run'] = params.dry_run
}
const result = await context.api.request<Schemas.WorkflowImportResponse>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_imports/`,
body,
})
return result
},
})
const WorkflowsImportNotesSchema = () => {
const WorkflowImportsForWorkflowRetrieveQueryParams = orvalSchemas.WorkflowImportsForWorkflowRetrieveQueryParams()
return WorkflowImportsForWorkflowRetrieveQueryParams
}
const workflowsImportNotes = (): ToolBase<
ReturnType<typeof WorkflowsImportNotesSchema>,
Schemas.WorkflowImportRecord
> => ({
name: 'workflows-import-notes',
schema: WorkflowsImportNotesSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsImportNotesSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.WorkflowImportRecord>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_imports/for_workflow/`,
query: {
hog_flow_id: params.hog_flow_id,
},
})
return result
},
})
const WorkflowsListSchema = () => {
const HogFlowsListQueryParams = orvalSchemas.HogFlowsListQueryParams()
return HogFlowsListQueryParams
}
const workflowsList = (): ToolBase<
ReturnType<typeof WorkflowsListSchema>,
WithPostHogUrl<Schemas.PaginatedHogFlowMinimalList>
> =>
withUiApp('workflow-list', {
name: 'workflows-list',
schema: WorkflowsListSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsListSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedHogFlowMinimalList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/`,
query: {
broadcast_eligible: params.broadcast_eligible,
broadcast_status: params.broadcast_status,
created_at: params.created_at,
created_by: params.created_by,
id: params.id,
latest_send_first: params.latest_send_first,
limit: params.limit,
name: params.name,
offset: params.offset,
optimization_enabled: params.optimization_enabled,
origin_product: params.origin_product,
search: params.search,
source_record: params.source_record,
status: params.status,
tags: params.tags,
trigger: params.trigger,
type: params.type,
updated_at: params.updated_at,
},
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsListBatchJobsSchema = () => {
const HogFlowsBatchJobsListParams = orvalSchemas.HogFlowsBatchJobsListParams()
return HogFlowsBatchJobsListParams.omit({ project_id: true })
}
const workflowsListBatchJobs = (): ToolBase<
ReturnType<typeof WorkflowsListBatchJobsSchema>,
WithPostHogUrl<Schemas.HogFlowBatchJob[]>
> => ({
name: 'workflows-list-batch-jobs',
schema: WorkflowsListBatchJobsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsListBatchJobsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogFlowBatchJob[]>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/batch_jobs/`,
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsListInvocationsSchema = () => {
const HogFlowsInvocationResultsRetrieveParams = orvalSchemas.HogFlowsInvocationResultsRetrieveParams()
const HogFlowsInvocationResultsRetrieveQueryParams = orvalSchemas.HogFlowsInvocationResultsRetrieveQueryParams()
return HogFlowsInvocationResultsRetrieveParams.omit({ project_id: true }).extend(
HogFlowsInvocationResultsRetrieveQueryParams.shape
)
}
const workflowsListInvocations = (): ToolBase<
ReturnType<typeof WorkflowsListInvocationsSchema>,
WithPostHogUrl<Schemas.HogInvocationResult[]>
> => ({
name: 'workflows-list-invocations',
schema: WorkflowsListInvocationsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsListInvocationsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.HogInvocationResult[]>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/invocation_results/`,
query: {
after: params.after,
before: params.before,
distinct_id: params.distinct_id,
error_message_contains: params.error_message_contains,
limit: params.limit,
status: params.status,
},
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsListProposalsSchema = () => {
const HogFlowsProposalsListParams = orvalSchemas.HogFlowsProposalsListParams()
const HogFlowsProposalsListQueryParams = orvalSchemas.HogFlowsProposalsListQueryParams()
return HogFlowsProposalsListParams.omit({ project_id: true }).extend(HogFlowsProposalsListQueryParams.shape)
}
const workflowsListProposals = (): ToolBase<
ReturnType<typeof WorkflowsListProposalsSchema>,
WithPostHogUrl<Schemas.PaginatedWorkflowProposalList>
> => ({
name: 'workflows-list-proposals',
schema: WorkflowsListProposalsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsListProposalsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedWorkflowProposalList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/proposals/`,
query: {
limit: params.limit,
offset: params.offset,
status: params.status,
},
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsListRevisionsSchema = () => {
const HogFlowsRevisionsListParams = orvalSchemas.HogFlowsRevisionsListParams()
const HogFlowsRevisionsListQueryParams = orvalSchemas.HogFlowsRevisionsListQueryParams()
return HogFlowsRevisionsListParams.omit({ project_id: true }).extend(HogFlowsRevisionsListQueryParams.shape)
}
const workflowsListRevisions = (): ToolBase<
ReturnType<typeof WorkflowsListRevisionsSchema>,
WithPostHogUrl<Schemas.PaginatedHogFlowRevisionBasicList>
> => ({
name: 'workflows-list-revisions',
schema: WorkflowsListRevisionsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsListRevisionsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedHogFlowRevisionBasicList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/revisions/`,
query: {
limit: params.limit,
offset: params.offset,
},
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsListVersionsSchema = () => {
const HogFlowsRevisionsListParams = orvalSchemas.HogFlowsRevisionsListParams()
const HogFlowsRevisionsListQueryParams = orvalSchemas.HogFlowsRevisionsListQueryParams()
return HogFlowsRevisionsListParams.omit({ project_id: true }).extend(HogFlowsRevisionsListQueryParams.shape)
}
const workflowsListVersions = (): ToolBase<
ReturnType<typeof WorkflowsListVersionsSchema>,
WithPostHogUrl<Schemas.PaginatedHogFlowRevisionBasicList>
> => ({
name: 'workflows-list-versions',
schema: WorkflowsListVersionsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsListVersionsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.PaginatedHogFlowRevisionBasicList>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/revisions/`,
query: {
limit: params.limit,
offset: params.offset,
},
})
return await withPostHogUrl(context, result, '/workflows')
},
})
const WorkflowsLogsSchema = () => {
const HogFlowsLogsRetrieveParams = orvalSchemas.HogFlowsLogsRetrieveParams()
const HogFlowsLogsRetrieveQueryParams = orvalSchemas.HogFlowsLogsRetrieveQueryParams()
return HogFlowsLogsRetrieveParams.omit({ project_id: true }).extend(HogFlowsLogsRetrieveQueryParams.shape)
}
const workflowsLogs = (): ToolBase<ReturnType<typeof WorkflowsLogsSchema>, unknown> => ({
name: 'workflows-logs',
schema: WorkflowsLogsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsLogsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<unknown>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/logs/`,
query: {
after: params.after,
before: params.before,
instance_id: params.instance_id,
level: params.level,
limit: params.limit,
offset: params.offset,
search: params.search,
},
})
return result
},
})
const WorkflowsPatchActionEmailSchema = () => WorkflowActionEmailPatchSchema
const workflowsPatchActionEmail = (): ToolBase<
ReturnType<typeof WorkflowsPatchActionEmailSchema>,
Schemas.HogFlow
> => ({
name: 'workflows-patch-action-email',
schema: WorkflowsPatchActionEmailSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsPatchActionEmailSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const parsedParams = WorkflowsPatchActionEmailSchema().parse(params)
const { id, action_id, ...body } = parsedParams
const result = await context.api.request<Schemas.HogFlow>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(id))}/actions/${encodeURIComponent(String(action_id))}/email/`,
body,
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return filtered
},
})
const WorkflowsPatchGraphSchema = () => WorkflowGraphPatchSchema
const workflowsPatchGraph = (): ToolBase<ReturnType<typeof WorkflowsPatchGraphSchema>, Schemas.HogFlow> => ({
name: 'workflows-patch-graph',
schema: WorkflowsPatchGraphSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsPatchGraphSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const parsedParams = WorkflowsPatchGraphSchema().parse(params)
const { id, ...body } = parsedParams
const result = await context.api.request<Schemas.HogFlow>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(id))}/graph/`,
body,
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return filtered
},
})
const WorkflowsPublishSchema = () => {
const HogFlowsPublishCreateBody = orvalSchemas.HogFlowsPublishCreateBody()
const HogFlowsPublishCreateParams = orvalSchemas.HogFlowsPublishCreateParams()
return HogFlowsPublishCreateParams.omit({ project_id: true }).extend(HogFlowsPublishCreateBody.shape)
}
const workflowsPublish = (): ToolBase<ReturnType<typeof WorkflowsPublishSchema>, Schemas.HogFlowPublishResponse> => ({
name: 'workflows-publish',
schema: WorkflowsPublishSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsPublishSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.confirm !== undefined) {
body['confirm'] = params.confirm
}
if (params.confirm_token !== undefined) {
body['confirm_token'] = params.confirm_token
}
const result = await context.api.request<Schemas.HogFlowPublishResponse>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/publish/`,
body,
})
const filtered = omitResponseFields(result, [
'workflow.actions.*.config.inputs',
'workflow.draft.actions.*.config.inputs',
]) as typeof result
return filtered
},
})
const WorkflowsReputationGetSchema = () => {
const HogFlowsReputationRetrieveQueryParams = orvalSchemas.HogFlowsReputationRetrieveQueryParams()
return HogFlowsReputationRetrieveQueryParams.extend({
fields: z
.array(
z.enum([
'sending_allowance',
'reputation',
'workflows',
'aws',
'isps',
'isp_shared_domains',
'isp_withheld_domains',
'email_sending_suspended',
'email_sending_suspended_at',
'email_sending_suspension_reason',
])
)
.min(1)
.optional()
.describe(
'Optional subset of response fields to return, each a dot-path from the allowlist. Omit to return all fields. Request only the fields your task needs to keep responses small.'
),
})
}
const workflowsReputationGet = (): ToolBase<
ReturnType<typeof WorkflowsReputationGetSchema>,
Schemas.TeamEmailReputationResponse
> => ({
name: 'workflows-reputation-get',
schema: WorkflowsReputationGetSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsReputationGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.TeamEmailReputationResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/reputation/`,
query: {
search: params.search,
},
})
const filtered = pickResponseFields(
result,
params.fields?.length
? params.fields
: [
'sending_allowance',
'reputation',
'workflows',
'aws',
'isps',
'isp_shared_domains',
'isp_withheld_domains',
'email_sending_suspended',
'email_sending_suspended_at',
'email_sending_suspension_reason',
]
) as typeof result
return filtered
},
})
const WorkflowsRestoreRevisionSchema = () => {
const HogFlowsRevisionsRestoreCreateBody = orvalSchemas.HogFlowsRevisionsRestoreCreateBody()
const HogFlowsRevisionsRestoreCreateParams = orvalSchemas.HogFlowsRevisionsRestoreCreateParams()
return HogFlowsRevisionsRestoreCreateParams.omit({ project_id: true }).extend(
HogFlowsRevisionsRestoreCreateBody.shape
)
}
const workflowsRestoreRevision = (): ToolBase<ReturnType<typeof WorkflowsRestoreRevisionSchema>, Schemas.HogFlow> => ({
name: 'workflows-restore-revision',
schema: WorkflowsRestoreRevisionSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsRestoreRevisionSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.overwrite !== undefined) {
body['overwrite'] = params.overwrite
}
if (params.expected_draft_updated_at !== undefined) {
body['expected_draft_updated_at'] = params.expected_draft_updated_at
}
const result = await context.api.request<Schemas.HogFlow>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/revisions/${encodeURIComponent(String(params.version))}/restore/`,
body,
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return filtered
},
})
const WorkflowsSendingRulesGetSchema = () => z.object({})
const workflowsSendingRulesGet = (): ToolBase<
ReturnType<typeof WorkflowsSendingRulesGetSchema>,
Schemas.WorkflowSendingRules
> =>
withUiApp('workflow-sending-rules', {
name: 'workflows-sending-rules-get',
schema: WorkflowsSendingRulesGetSchema(),
handler: async (context: Context, _params: z.infer<ReturnType<typeof WorkflowsSendingRulesGetSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.WorkflowSendingRules>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_sending_rules/current/`,
})
return result
},
})
const WorkflowsSendingRulesUpdateSchema = () => {
const WorkflowSendingRulesPartialUpdateBody = orvalSchemas.WorkflowSendingRulesPartialUpdateBody()
return WorkflowSendingRulesPartialUpdateBody
}
const workflowsSendingRulesUpdate = (): ToolBase<
ReturnType<typeof WorkflowsSendingRulesUpdateSchema>,
Schemas.WorkflowSendingRules
> =>
withUiApp('workflow-sending-rules', {
name: 'workflows-sending-rules-update',
schema: WorkflowsSendingRulesUpdateSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsSendingRulesUpdateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.expected_project_id !== undefined) {
body['expected_project_id'] = params.expected_project_id
}
if (params.marketing_frequency_cap_max_messages !== undefined) {
body['marketing_frequency_cap_max_messages'] = params.marketing_frequency_cap_max_messages
}
if (params.marketing_frequency_cap_window_days !== undefined) {
body['marketing_frequency_cap_window_days'] = params.marketing_frequency_cap_window_days
}
if (params.marketing_frequency_cap_hold_hours !== undefined) {
body['marketing_frequency_cap_hold_hours'] = params.marketing_frequency_cap_hold_hours
}
if (params.email_tracking_consent_mode !== undefined) {
body['email_tracking_consent_mode'] = params.email_tracking_consent_mode
}
if (params.capture_workflows_engagement_events !== undefined) {
body['capture_workflows_engagement_events'] = params.capture_workflows_engagement_events
}
const result = await context.api.request<Schemas.WorkflowSendingRules>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_sending_rules/current/`,
body,
})
return result
},
})
const WorkflowsSetupStatusSchema = () => z.object({})
const workflowsSetupStatus = (): ToolBase<ReturnType<typeof WorkflowsSetupStatusSchema>, Schemas.WorkflowSetupStatus> =>
withUiApp('workflow-setup-status', {
name: 'workflows-setup-status',
schema: WorkflowsSetupStatusSchema(),
handler: async (context: Context, _params: z.infer<ReturnType<typeof WorkflowsSetupStatusSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.WorkflowSetupStatus>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/workflow_setup/status/`,
})
return result
},
})
const WorkflowsStatsSchema = () => {
const HogFlowsMetricsRetrieveParams = orvalSchemas.HogFlowsMetricsRetrieveParams()
const HogFlowsMetricsRetrieveQueryParams = orvalSchemas.HogFlowsMetricsRetrieveQueryParams()
return HogFlowsMetricsRetrieveParams.omit({ project_id: true }).extend(HogFlowsMetricsRetrieveQueryParams.shape)
}
const workflowsStats = (): ToolBase<ReturnType<typeof WorkflowsStatsSchema>, Schemas.AppMetricsResponse> => ({
name: 'workflows-stats',
schema: WorkflowsStatsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsStatsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.AppMetricsResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/metrics/`,
query: {
after: params.after,
before: params.before,
breakdown_by: params.breakdown_by,
instance_id: params.instance_id,
interval: params.interval,
kind: params.kind,
name: params.name,
},
})
return result
},
})
const WorkflowsSuggestSchema = () => {
const HogFlowsProposalsCreateBody = orvalSchemas.HogFlowsProposalsCreateBody()
const HogFlowsProposalsCreateParams = orvalSchemas.HogFlowsProposalsCreateParams()
return HogFlowsProposalsCreateParams.omit({ project_id: true }).extend(HogFlowsProposalsCreateBody.shape)
}
const workflowsSuggest = (): ToolBase<ReturnType<typeof WorkflowsSuggestSchema>, Schemas.WorkflowProposal> => ({
name: 'workflows-suggest',
schema: WorkflowsSuggestSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsSuggestSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.title !== undefined) {
body['title'] = params.title
}
if (params.rationale !== undefined) {
body['rationale'] = params.rationale
}
if (params.content !== undefined) {
body['content'] = params.content
}
if (params.evidence !== undefined) {
body['evidence'] = params.evidence
}
if (params.base_version !== undefined) {
body['base_version'] = params.base_version
}
if (params.step_id !== undefined) {
body['step_id'] = params.step_id
}
if (params.source_id !== undefined) {
body['source_id'] = params.source_id
}
const result = await context.api.request<Schemas.WorkflowProposal>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/proposals/`,
body,
})
return result
},
})
const WorkflowsTestRunSchema = () => {
const HogFlowsInvocationsCreateBody = orvalSchemas.HogFlowsInvocationsCreateBody()
const HogFlowsInvocationsCreateParams = orvalSchemas.HogFlowsInvocationsCreateParams()
return HogFlowsInvocationsCreateParams.omit({ project_id: true }).extend(HogFlowsInvocationsCreateBody.shape)
}
const workflowsTestRun = (): ToolBase<ReturnType<typeof WorkflowsTestRunSchema>, unknown> => ({
name: 'workflows-test-run',
schema: WorkflowsTestRunSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsTestRunSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.globals !== undefined) {
body['globals'] = params.globals
}
if (params.mock_async_functions !== undefined) {
body['mock_async_functions'] = params.mock_async_functions
}
if (params.current_action_id !== undefined) {
body['current_action_id'] = params.current_action_id
}
if (params.use_draft !== undefined) {
body['use_draft'] = params.use_draft
}
const result = await context.api.request<unknown>({
method: 'POST',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/invocations/`,
body,
})
return result
},
})
const WorkflowsUpdateSchema = () => {
const HogFlowsPartialUpdateBody = orvalSchemas.HogFlowsPartialUpdateBody()
const HogFlowsPartialUpdateParams = orvalSchemas.HogFlowsPartialUpdateParams()
return HogFlowsPartialUpdateParams.omit({ project_id: true }).extend(HogFlowsPartialUpdateBody.shape)
}
const workflowsUpdate = (): ToolBase<ReturnType<typeof WorkflowsUpdateSchema>, WithPostHogUrl<Schemas.HogFlowUpdate>> =>
withUiApp('workflow', {
name: 'workflows-update',
schema: WorkflowsUpdateSchema(),
handler: withToolHooks(
hooks_workflowsUpdate,
async (context: Context, params: z.infer<ReturnType<typeof WorkflowsUpdateSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.name !== undefined) {
body['name'] = params.name
}
if (params.description !== undefined) {
body['description'] = params.description
}
if (params.tags !== undefined) {
body['tags'] = params.tags
}
if (params.trigger_masking !== undefined) {
body['trigger_masking'] = params.trigger_masking
}
if (params.conversion !== undefined) {
body['conversion'] = params.conversion
}
if (params.exit_condition !== undefined) {
body['exit_condition'] = params.exit_condition
}
if (params.email_sending_rate_limit !== undefined) {
body['email_sending_rate_limit'] = params.email_sending_rate_limit
}
if (params.variables !== undefined) {
body['variables'] = params.variables
}
const result = await context.api.request<Schemas.HogFlowUpdate>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/`,
body: await transformRequestBody(hooks_workflowsUpdate, context, params, body),
})
const filtered = omitResponseFields(result, [
'actions.*.config.inputs',
'draft.actions.*.config.inputs',
]) as typeof result
return await withPostHogUrl(context, filtered, `/workflows/${filtered.id}/workflow`)
}
),
})
const WorkflowsUpdateScheduleSchema = () => {
const HogFlowsSchedulesPartialUpdateBody = orvalSchemas.HogFlowsSchedulesPartialUpdateBody()
const HogFlowsSchedulesPartialUpdateParams = orvalSchemas.HogFlowsSchedulesPartialUpdateParams()
return HogFlowsSchedulesPartialUpdateParams.omit({ project_id: true }).extend(
HogFlowsSchedulesPartialUpdateBody.shape
)
}
const workflowsUpdateSchedule = (): ToolBase<
ReturnType<typeof WorkflowsUpdateScheduleSchema>,
Schemas.HogFlowSchedule
> => ({
name: 'workflows-update-schedule',
schema: WorkflowsUpdateScheduleSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsUpdateScheduleSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const body: Record<string, unknown> = {}
if (params.rrule !== undefined) {
body['rrule'] = params.rrule
}
if (params.starts_at !== undefined) {
body['starts_at'] = params.starts_at
}
if (params.timezone !== undefined) {
body['timezone'] = params.timezone
}
if (params.variables !== undefined) {
body['variables'] = params.variables
}
const result = await context.api.request<Schemas.HogFlowSchedule>({
method: 'PATCH',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/schedules/${encodeURIComponent(String(params.schedule_id))}/`,
body,
})
return result
},
})
const WorkflowsVersionStatsSchema = () => {
const HogFlowsMetricsVersionRetrieveParams = orvalSchemas.HogFlowsMetricsVersionRetrieveParams()
const HogFlowsMetricsVersionRetrieveQueryParams = orvalSchemas.HogFlowsMetricsVersionRetrieveQueryParams()
return HogFlowsMetricsVersionRetrieveParams.omit({ project_id: true }).extend(
HogFlowsMetricsVersionRetrieveQueryParams.shape
)
}
const workflowsVersionStats = (): ToolBase<
ReturnType<typeof WorkflowsVersionStatsSchema>,
Schemas.AppMetricsResponse
> => ({
name: 'workflows-version-stats',
schema: WorkflowsVersionStatsSchema(),
handler: async (context: Context, params: z.infer<ReturnType<typeof WorkflowsVersionStatsSchema>>) => {
const projectId = await context.stateManager.getProjectId()
const result = await context.api.request<Schemas.AppMetricsResponse>({
method: 'GET',
path: `/api/projects/${encodeURIComponent(String(projectId))}/hog_flows/${encodeURIComponent(String(params.id))}/metrics/version/`,
query: {
after: params.after,
before: params.before,
breakdown_by: params.breakdown_by,
instance_id: params.instance_id,
interval: params.interval,
kind: params.kind,
name: params.name,
version: params.version,
},
})
return result
},
})
export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
'broadcasts-create': broadcastsCreate,
'workflows-convert-to-broadcast': workflowsConvertToBroadcast,
'workflows-create': workflowsCreate,
'workflows-data-suggestions-create': workflowsDataSuggestionsCreate,
'workflows-data-suggestions-get': workflowsDataSuggestionsGet,
'workflows-data-suggestions-list': workflowsDataSuggestionsList,
'workflows-discard-draft': workflowsDiscardDraft,
'workflows-email-drafts-create': workflowsEmailDraftsCreate,
'workflows-get': workflowsGet,
'workflows-get-invocation': workflowsGetInvocation,
'workflows-get-revision': workflowsGetRevision,
'workflows-global-stats': workflowsGlobalStats,
'workflows-import-customerio': workflowsImportCustomerio,
'workflows-import-notes': workflowsImportNotes,
'workflows-list': workflowsList,
'workflows-list-batch-jobs': workflowsListBatchJobs,
'workflows-list-invocations': workflowsListInvocations,
'workflows-list-proposals': workflowsListProposals,
'workflows-list-revisions': workflowsListRevisions,
'workflows-list-versions': workflowsListVersions,
'workflows-logs': workflowsLogs,
'workflows-patch-action-email': workflowsPatchActionEmail,
'workflows-patch-graph': workflowsPatchGraph,
'workflows-publish': workflowsPublish,
'workflows-reputation-get': workflowsReputationGet,
'workflows-restore-revision': workflowsRestoreRevision,
'workflows-sending-rules-get': workflowsSendingRulesGet,
'workflows-sending-rules-update': workflowsSendingRulesUpdate,
'workflows-setup-status': workflowsSetupStatus,
'workflows-stats': workflowsStats,
'workflows-suggest': workflowsSuggest,
'workflows-test-run': workflowsTestRun,
'workflows-update': workflowsUpdate,
'workflows-update-schedule': workflowsUpdateSchedule,
'workflows-version-stats': workflowsVersionStats,
}