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.

feat(workflows): add mcp tools and a skill for customer.io imports (#122457)

Daniel Marchuk987de3d6718e
diff --git a/products/workflows/mcp/tools.yaml b/products/workflows/mcp/tools.yaml
index dba121885021..99ca3f28a9fc 100644
--- a/products/workflows/mcp/tools.yaml
+++ b/products/workflows/mcp/tools.yaml
@@ -285,6 +285,44 @@ tools:
workflows are failing, then drill into those with workflows-list-invocations (who it failed for) →
workflows-get-invocation (the triggering payload) → workflows-logs (the failing step). Avoids scanning every
workflow one at a time. For a single workflow's time-series, use workflows-stats.
+ workflows-import-customerio:
+ operation: workflow_imports_create
+ enabled: true
+ scopes:
+ - hog_flow:write
+ annotations:
+ readOnly: false
+ destructive: true
+ idempotent: true
+ title: Import Customer.io automations
+ description: >
+ Turn Customer.io automations into draft PostHog workflows. Read each automation with the Customer.io MCP or
+ CLI first: GET /v1/environments/{environment_id}/campaigns/{campaign_id} gives `campaign` and `actions`.
+ Pass them unchanged; never pass people or customer profiles. Leave message templates out on the first call:
+ when the project stored a Customer.io App API key, PostHog reads the content itself and the response says
+ content_fetched=true. For each automation whose notes still say its message content was not part of the
+ import, read each message action's template with GET
+ /v1/environments/{environment_id}/templates/{template_id} and pass them. Pass snippets that notes name. In a
+ preview, a workflow_id means the import replaces that existing draft. Pass sender identities and segment
+ ids, names and types too, never segment members. Run once with dry_run=true and show the user each
+ automation's notes, then import for real. Drafts never send until a person enables them. Re-importing an
+ automation replaces its draft, discarding edits made there since, so confirm with the user first. Share each
+ draft's link and the notes marked needs_input, since the team must set those before enabling.
+ feature_flag: workflows-customerio-import
+ workflows-import-notes:
+ operation: workflow_imports_for_workflow_retrieve
+ enabled: true
+ scopes:
+ - hog_flow:read
+ annotations:
+ readOnly: true
+ destructive: false
+ idempotent: true
+ title: Get a workflow's import notes
+ description: >
+ What importing a workflow from Customer.io changed or left out, step by step. Returns an empty response for
+ a workflow that was not imported.
+ feature_flag: workflows-customerio-import
workflows-list:
operation: hog_flows_list
enabled: true
diff --git a/products/workflows/skills/migrating-from-customer-io/SKILL.md b/products/workflows/skills/migrating-from-customer-io/SKILL.md
new file mode 100644
index 000000000000..2e2b8dc34ed5
--- /dev/null
+++ b/products/workflows/skills/migrating-from-customer-io/SKILL.md
@@ -0,0 +1,62 @@
+---
+name: migrating-from-customer-io
+description: 'Move Customer.io automations into PostHog as draft workflows. Read each automation with the Customer.io MCP or CLI, preview the import with workflows-import-customerio (dry_run), then import and walk the user through what needs their input. Use when asked to migrate, move, switch, copy or import from Customer.io (customer.io, CIO) to PostHog workflows, including "migrate everything to PostHog".'
+---
+
+# Migrating from Customer.io
+
+PostHog imports Customer.io automations as **draft workflows**. Drafts never send. A person reviews each one, fixes what the import could not carry over, and enables it.
+
+You move the data between two MCP servers. Read from Customer.io's MCP (or the `cio` CLI), and pass what it returns **unchanged** to PostHog's `workflows-import-customerio`. PostHog does the translation, so do not rebuild workflows yourself with `workflows-create`.
+
+## Never move people
+
+Pass automations, templates, sender identities and segment names only. Never fetch or pass customer profiles, segment members, deliveries or event data. The people are usually in PostHog already, and copying them is a privacy risk the user did not ask for.
+
+## Keep message content out of your context
+
+Email templates are large, often tens of kilobytes of HTML each. When the PostHog project stored a Customer.io App API key (teams that ran the opt-out import have one), PostHog reads the message content from Customer.io itself. So pass the automation graph first, and read templates only if PostHog asks for them.
+
+## Steps
+
+1. **Find the environment.** Ask which Customer.io workspace to migrate if there is more than one. Its id is the `environment_id` in every path below.
+2. **List the automations.** `GET /v1/environments/{environment_id}/campaigns` with the Customer.io read tool (`cio_read_api` on the MCP, `cio api` on the CLI). It returns 20 per page through `page` (0-based): read every page until one returns fewer than 20. Show the user the list with each automation's state, and ask which to move. Running automations are the usual answer; skip archived ones unless asked.
+3. **Read each automation.** `GET /v1/environments/{environment_id}/campaigns/{campaign_id}`. Keep the response's `campaign` object and its **top-level** `actions` array. `campaign.actions` does not exist.
+4. **Read senders and segments.** `GET /v1/environments/{environment_id}/identities?type=email` for `sender_identities` (`id`, `email`, `name`), and the segment list for `segments` (`id`, `name`, `type` only). PostHog matches each email to the PostHog sender with the same address, and names the segments in its notes.
+5. **Preview without templates.** Call `workflows-import-customerio` with `source: "customerio"`, `dry_run: true`, `campaigns: [{campaign, actions}]`, `sender_identities` and `segments`. Up to 50 automations per call.
+6. **Read templates only if needed.** Go by each automation's notes, not by `content_fetched` alone: `true` only means PostHog read some content, and one automation can still miss its messages. For every automation whose notes say message content was not part of the import, or that PostHog could not read its messages, read the template of every action that has a `template_id` with `GET /v1/environments/{environment_id}/templates/{template_id}`, keep the `template` object, and preview again with `campaigns: [{campaign, actions, templates}]`. Read templates one at a time: listing every template in the workspace times out on large ones. Tell the user that Import from Customer.io on the Workflows Opt-outs tab stores their App API key, which skips this step next time.
+7. **Collect snippets and layouts.** If a note names a Customer.io snippet, or a template body you read contains `{% snippet "name" %}`, read the workspace snippets and pass them as `snippets` (`{name: content}`). When PostHog read the content itself, the notes are the only place the snippet names appear. If a note names a layout, read `GET /v1/environments/{environment_id}/layouts/{layout_id}` and pass its `body` as `layouts` (`{layout_id: body}`).
+8. **Report the preview.** For each automation, give its status and its notes, grouped by level (see below). Ask before importing anything with status `failed`; its `validation_errors` say why the draft would be rejected.
+9. **Import.** Call again with `dry_run: false` and the same arguments. Share each draft's link (`/workflows/{workflow_id}`) and the `needs_input` notes again, since the team must handle those before enabling.
+
+When you are unsure of an endpoint's parameters, ask for that one endpoint's schema (`cio_schema` with `resource.method`). A whole resource's schema costs tens of thousands of tokens.
+
+## Reading the notes
+
+| Level | Meaning | What to tell the user |
+| -------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------- |
+| `needs_input` | The draft needs a setting only the team can give: an email sender, a trigger cohort, a branch condition | These block enabling. List them per workflow. |
+| `approximated` | The step works differently in PostHog, for example a wait capped at 30 days | Worth a look before enabling. |
+| `unsupported` | The setting has no PostHog equivalent and was left out, for example an SMS step | Decide whether to rebuild it another way. |
+
+The same notes appear in the PostHog app on the imported workflow, and `workflows-import-notes` returns them for one workflow.
+
+## Senders and categories
+
+An email gets the PostHog email sender with the same address as its Customer.io sender. When no PostHog sender has that address, a `needs_input` note names it, so the user can add it as a sender. An email's subscription topic becomes the PostHog message category the opt-out import made from that topic. When the topics were not imported, a note says so.
+
+## Segments and cohorts
+
+Customer.io segments do not import. An automation triggered by a segment imports with an empty trigger and a `needs_input` note. If the user already has a PostHog cohort that matches a segment, pass `segment_cohorts: {"<segment id>": <cohort id>}` and the import uses it for that segment's triggers and conditions. A cohort trigger needs a realtime cohort. A static segment gets its own note: workflows cannot check a static cohort, so the user rebuilds it as conditions.
+
+## Push notifications
+
+Push steps import as `unsupported` notes, and device tokens never move with the import. If the user sends push from Customer.io, tell them that a device reaches PostHog only when its app registers it with the PostHog SDK, or when they import their exported device tokens into a PostHog push channel. That token import is a separate step the user starts, because tokens are people data.
+
+## Re-running
+
+Importing an automation again replaces its draft, so you can re-run after fixing something in Customer.io. Edits the team made to that draft since are lost, so ask before you re-import. A workflow that someone already enabled, or that the user can't edit, is never changed: its result is `skipped`.
+
+## After the import
+
+Do not enable the drafts. Point the user at the `needs_input` notes, then hand over to the `building-workflows` skill for testing and enabling, which needs the user's explicit sign-off.
diff --git a/services/mcp/schema/generated-tool-definitions.json b/services/mcp/schema/generated-tool-definitions.json
index 7692610d6466..a0e5d13fe25a 100644
--- a/services/mcp/schema/generated-tool-definitions.json
+++ b/services/mcp/schema/generated-tool-definitions.json
@@ -16852,6 +16852,38 @@
"readOnlyHint": true
}
},
+ "workflows-import-customerio": {
+ "description": "Turn Customer.io automations into draft PostHog workflows. Read each automation with the Customer.io MCP or CLI first: GET /v1/environments/{environment_id}/campaigns/{campaign_id} gives `campaign` and `actions`. Pass them unchanged; never pass people or customer profiles. Leave message templates out on the first call: when the project stored a Customer.io App API key, PostHog reads the content itself and the response says content_fetched=true. For each automation whose notes still say its message content was not part of the import, read each message action's template with GET /v1/environments/{environment_id}/templates/{template_id} and pass them. Pass snippets that notes name. In a preview, a workflow_id means the import replaces that existing draft. Pass sender identities and segment ids, names and types too, never segment members. Run once with dry_run=true and show the user each automation's notes, then import for real. Drafts never send until a person enables them. Re-importing an automation replaces its draft, discarding edits made there since, so confirm with the user first. Share each draft's link and the notes marked needs_input, since the team must set those before enabling.",
+ "category": "Workflows",
+ "feature": "workflows",
+ "summary": "Import Customer.io automations",
+ "title": "Import Customer.io automations",
+ "required_scopes": ["hog_flow:write"],
+ "api_operations": ["POST /api/projects/{project_id}/workflow_imports/"],
+ "annotations": {
+ "destructiveHint": true,
+ "idempotentHint": true,
+ "openWorldHint": true,
+ "readOnlyHint": false
+ },
+ "feature_flag": "workflows-customerio-import"
+ },
+ "workflows-import-notes": {
+ "description": "What importing a workflow from Customer.io changed or left out, step by step. Returns an empty response for a workflow that was not imported.",
+ "category": "Workflows",
+ "feature": "workflows",
+ "summary": "Get a workflow's import notes",
+ "title": "Get a workflow's import notes",
+ "required_scopes": ["hog_flow:read"],
+ "api_operations": ["GET /api/projects/{project_id}/workflow_imports/for_workflow/"],
+ "annotations": {
+ "destructiveHint": false,
+ "idempotentHint": true,
+ "openWorldHint": true,
+ "readOnlyHint": true
+ },
+ "feature_flag": "workflows-customerio-import"
+ },
"workflows-list": {
"description": "List all workflows in the project. Returns workflows with their name, description, status (draft/active/archived), version, trigger configuration, tags, and timestamps. Pass search=<text> to find a workflow by its name, description or a tag, or, when none of those match, by a step name or the subject, preheader or body text of an email it sends (live or pending draft), and read its id. Most workflows-* tools take that value as 'id'; workflows-blast-radius, workflows-run-batch and workflows-schedule-create take it as 'workflow_id'. Pass tags='[\"growth\"]' (a JSON-encoded list) to return only workflows that carry at least one of those tags.",
"category": "Workflows",
diff --git a/services/mcp/schema/tool-definitions-all.json b/services/mcp/schema/tool-definitions-all.json
index 04143f590430..ccac065db398 100644
--- a/services/mcp/schema/tool-definitions-all.json
+++ b/services/mcp/schema/tool-definitions-all.json
@@ -17671,6 +17671,38 @@
"readOnlyHint": true
}
},
+ "workflows-import-customerio": {
+ "description": "Turn Customer.io automations into draft PostHog workflows. Read each automation with the Customer.io MCP or CLI first: GET /v1/environments/{environment_id}/campaigns/{campaign_id} gives `campaign` and `actions`. Pass them unchanged; never pass people or customer profiles. Leave message templates out on the first call: when the project stored a Customer.io App API key, PostHog reads the content itself and the response says content_fetched=true. For each automation whose notes still say its message content was not part of the import, read each message action's template with GET /v1/environments/{environment_id}/templates/{template_id} and pass them. Pass snippets that notes name. In a preview, a workflow_id means the import replaces that existing draft. Pass sender identities and segment ids, names and types too, never segment members. Run once with dry_run=true and show the user each automation's notes, then import for real. Drafts never send until a person enables them. Re-importing an automation replaces its draft, discarding edits made there since, so confirm with the user first. Share each draft's link and the notes marked needs_input, since the team must set those before enabling.",
+ "category": "Workflows",
+ "feature": "workflows",
+ "summary": "Import Customer.io automations",
+ "title": "Import Customer.io automations",
+ "required_scopes": ["hog_flow:write"],
+ "api_operations": ["POST /api/projects/{project_id}/workflow_imports/"],
+ "annotations": {
+ "destructiveHint": true,
+ "idempotentHint": true,
+ "openWorldHint": true,
+ "readOnlyHint": false
+ },
+ "feature_flag": "workflows-customerio-import"
+ },
+ "workflows-import-notes": {
+ "description": "What importing a workflow from Customer.io changed or left out, step by step. Returns an empty response for a workflow that was not imported.",
+ "category": "Workflows",
+ "feature": "workflows",
+ "summary": "Get a workflow's import notes",
+ "title": "Get a workflow's import notes",
+ "required_scopes": ["hog_flow:read"],
+ "api_operations": ["GET /api/projects/{project_id}/workflow_imports/for_workflow/"],
+ "annotations": {
+ "destructiveHint": false,
+ "idempotentHint": true,
+ "openWorldHint": true,
+ "readOnlyHint": true
+ },
+ "feature_flag": "workflows-customerio-import"
+ },
"workflows-list": {
"description": "List all workflows in the project. Returns workflows with their name, description, status (draft/active/archived), version, trigger configuration, tags, and timestamps. Pass search=<text> to find a workflow by its name, description or a tag, or, when none of those match, by a step name or the subject, preheader or body text of an email it sends (live or pending draft), and read its id. Most workflows-* tools take that value as 'id'; workflows-blast-radius, workflows-run-batch and workflows-schedule-create take it as 'workflow_id'. Pass tags='[\"growth\"]' (a JSON-encoded list) to return only workflows that carry at least one of those tags.",
"category": "Workflows",
diff --git a/services/mcp/src/generated/workflows/api.ts b/services/mcp/src/generated/workflows/api.ts
index 306bd7dd6d4c..e5de503fd8be 100644
--- a/services/mcp/src/generated/workflows/api.ts
+++ b/services/mcp/src/generated/workflows/api.ts
@@ -3,7 +3,7 @@
* MCP service uses these Zod schemas for generated tool handlers.
* To regenerate: hogli build:openapi
*
- * PostHog API - MCP 30 enabled ops
+ * PostHog API - MCP 32 enabled ops
* OpenAPI spec version: 1.0.0
*/
import * as zod from 'zod'
@@ -1438,6 +1438,110 @@ export const WorkflowDataSuggestionsGenerateBody = () => zod.object({
.describe('Make new suggestions even when the cached ones are still valid.'),
})
+/**
+ * Turns Customer.io automations into draft workflows. Pass each automation as Customer.io's Journeys UI API returns it. Pass the templates its messages use, or leave them out when the project stored a Customer.io App API key, and PostHog reads them. Each result lists what the import changed or left out. Importing an automation again updates its draft, unless that workflow is no longer a draft. Set dry_run to preview without saving.
+ * @summary Import Customer.io automations as draft workflows
+ */
+export const WorkflowImportsCreateParams = () => zod.object({
+ project_id: zod
+ .string()
+ .describe(
+ "Project ID of the project you're trying to access. To find the ID of the project, make a call to \/api\/projects\/."
+ ),
+})
+
+export const workflowImportsCreateBodySenderIdentitiesItemNameDefault = ``
+export const workflowImportsCreateBodyDryRunDefault = false
+
+export const WorkflowImportsCreateBody = () => zod.object({
+ source: zod
+ .enum(['customerio'])
+ .describe('\* `customerio` - Customer.io')
+ .describe('The tool the automations come from.\n\n\* `customerio` - Customer.io'),
+ campaigns: zod
+ .array(
+ zod.object({
+ campaign: zod
+ .record(zod.string(), zod.unknown())
+ .describe(
+ "The `campaign` object from Customer.io's `GET \/v1\/environments\/{environment_id}\/campaigns\/{campaign_id}` (Journeys UI API, what the Customer.io CLI and MCP read). Must include `id`, `type`, `edges` and the trigger fields."
+ ),
+ actions: zod
+ .array(zod.record(zod.string(), zod.unknown()))
+ .describe('The top-level `actions` array from the same response, every step of the automation.'),
+ templates: zod
+ .unknown()
+ .optional()
+ .describe(
+ 'The message templates the actions point at, from `GET \/v1\/environments\/{environment_id}\/templates\/{template_id}`: a list of template objects, or an object keyed by template id. Leave them out when the project stored a Customer.io App API key: PostHog then reads the content from Customer.io itself. Without either, messages import with empty content.'
+ ),
+ })
+ )
+ .describe('The automations to import, at most 50. People are never read from these objects.'),
+ snippets: zod
+ .record(zod.string(), zod.string())
+ .optional()
+ .describe('Customer.io snippet name to its content, inlined where a message uses `{% snippet \"name\" %}`.'),
+ segment_cohorts: zod
+ .record(zod.string(), zod.number())
+ .optional()
+ .describe(
+ 'Customer.io segment id to the PostHog cohort that replaces it. Segment triggers and segment conditions with no cohort here are left for the team to set.'
+ ),
+ layouts: zod
+ .record(zod.string(), zod.string())
+ .optional()
+ .describe(
+ "Customer.io layout id to the layout's `body`, from `GET \/v1\/environments\/{environment_id}\/layouts\/{layout_id}`. An email whose template names a `layout_id` is wrapped in that layout at `{{ content }}`."
+ ),
+ sender_identities: zod
+ .array(
+ zod.object({
+ id: zod.string().describe("The sender identity's id, which templates name in `from_identity_id`."),
+ email: zod.email().describe('The address the sender sends from.'),
+ name: zod
+ .string()
+ .default(workflowImportsCreateBodySenderIdentitiesItemNameDefault)
+ .describe("The sender's display name."),
+ })
+ )
+ .optional()
+ .describe(
+ 'Customer.io sender identities, from `GET \/v1\/environments\/{environment_id}\/identities?type=email`. Each email gets the PostHog sender with the same address.'
+ ),
+ segments: zod
+ .array(
+ zod.object({
+ id: zod.string().describe("The segment's id."),
+ name: zod.string().describe("The segment's name."),
+ type: zod.string().describe("The segment's type: `dynamic`, or `static` for a hand-made list."),
+ })
+ )
+ .optional()
+ .describe(
+ 'Customer.io segment ids, names and types, without members, so the notes can name each segment and flag static ones.'
+ ),
+ dry_run: zod
+ .boolean()
+ .default(workflowImportsCreateBodyDryRunDefault)
+ .describe('When true, translate and check the automations but save nothing, to preview the import.'),
+})
+
+/**
+ * @summary Read what importing a workflow changed or left out
+ */
+export const WorkflowImportsForWorkflowRetrieveParams = () => zod.object({
+ project_id: zod
+ .string()
+ .describe(
+ "Project ID of the project you're trying to access. To find the ID of the project, make a call to \/api\/projects\/."
+ ),
+})
+
+export const WorkflowImportsForWorkflowRetrieveQueryParams = () => zod.object({
+ hog_flow_id: zod.string().describe('The workflow to read the import of.'),
+})
+
/**
* The project-wide rules every workflow and broadcast follows when it sends a message.
*/
diff --git a/services/mcp/src/tools/generated/workflows.ts b/services/mcp/src/tools/generated/workflows.ts
index e320ba1883f7..b8f03b81c1f4 100644
--- a/services/mcp/src/tools/generated/workflows.ts
+++ b/services/mcp/src/tools/generated/workflows.ts
@@ -368,6 +368,77 @@ const workflowsGlobalStats = (): ToolBase<
},
})
+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
@@ -1035,6 +1106,8 @@ export const GENERATED_TOOLS: Record<string, () => ToolBase<ZodObjectAny>> = {
'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,
diff --git a/services/mcp/tests/unit/tool-filtering.test.ts b/services/mcp/tests/unit/tool-filtering.test.ts
index d6b7f24cad3e..e629f694d758 100644
--- a/services/mcp/tests/unit/tool-filtering.test.ts
+++ b/services/mcp/tests/unit/tool-filtering.test.ts
@@ -1128,6 +1128,7 @@ describe('Tool Filtering - Feature Flags', () => {
'workflows-email-domain-agent-setup',
'feature-flag-rules-v2-mcp',
'investigate-insight',
+ 'workflows-customerio-import',
'mcp-session-recording-console-logs',
]
expect(allFlags).toEqual(expect.arrayContaining(branchFlags))