Connect AI agents to the Plain MCP server

Fetch a customer's full profile including email, assignment, company, and timestamps.

Return a paginated list of all customers in the workspace.

Return all threads belonging to a specific customer, with optional status filtering.

Fetch a single Help Center article by its ID.

Fetch a Help Center article by its URL slug.

Return all article groups for a Help Center.

Return a paginated list of articles in a Help Center.

Return all Help Centers in the workspace.

Return all label types available in the workspace.

Return threads assigned to the authenticated user, with optional status and priority filters.

Return the profile of the currently authenticated workspace user.

Return details about the current workspace including its ID and name.

Poll a Sidekick session: read its status, its newest messages, and any approval it is blocked on. Call this repeatedly after startSidekickSession or sendSidekickMessage.

Fetch a single snippet by ID, including soft-deleted snippets (where isDeleted is true). Use this when you already have a snippet ID from getSnippets or another tool.

Fetch a paginated list of snippets from the workspace. Snippets are reusable reply templates that agents insert when composing replies. Soft-deleted snippets are excluded from this list.

Fetch full details for a specific tenant by its ID.

Return a paginated list of all tenants in the workspace.

Fetch a thread's full details and timeline entries by thread ID.

Return all custom thread field schemas defined in the workspace.

Fetch the knowledge sources cited by AI agent replies on a thread. Currently only Ari, Plain's AI support agent, produces citations. Correlate timelineEntryId with the timeline entry id values from getThreadDetails to see which reply cited which source. Returns an empty list when the thread has no citations.

Return threads with flexible filtering by status, priority, assignee, customer, labels, or date range.

Look up a workspace user by their email address.

List Sidekick sessions in the workspace, most recent activity first. Use this to resume a session from an earlier conversation, check whether a session landed after a timeout, or find sessions that need attention. Pass agentStatuses: [NEEDS_INPUT] for sessions blocked on a human approval decision, or agentStatuses: [IN_PROGRESS] for ones still working. statuses is the session's own lifecycle (OPEN/RESOLVED) and does not overlap with agentStatuses.

Search customers by name or email and return a paginated list of matches.

Search tenants by name and return matching results.

Search a connected issue tracker for external entities that can be linked to a thread via createThreadLink. Scope the search to one issue tracker with sourceType (e.g. jira_issue, incidentio_incident, shortcut_story, rootly_incident, github_issue) and match against issue titles or identifiers with the free-text searchQuery. Requires a connected issue tracker integration for the given sourceType.

Search threads by text with optional filters for status, priority, assignee, customer, and labels.

Accepts one or more pending suggested label types, creating a real label type for each and marking the suggestions as ACCEPTED. All ids must currently be PENDING. Fails the whole batch with error code `label_type_name_already_exists` if a suggestion's name matches an existing label type or another suggestion in the same batch. Requires the `labelType:create` and `labelType:read` permissions. Arguments: - input: AcceptSuggestedLabelTypesInput!

Fetches a single account by its Plain-assigned ID. Returns null if no matching account is found. Requires the `tenant:read` permission. Arguments: - accountId: ID!

Returns the list of account field schemas defined in the workspace. Use the `source` and `isVisible` filters to narrow results. Supports cursor-based pagination. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: AccountFieldSchemasFilter - first: Int - after: String - last: Int - before: String

Returns a paginated list of accounts in the workspace. Use the `filters` argument to narrow the results and `sortBy` to order them (by name ascending when omitted). Requires the `tenant:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String - filters: AccountsFilter - sortBy: AccountsSort

Returns the cluster that the given thread currently belongs to, or null if the thread has not been assigned to any cluster. Use this to show a customer-support agent which broader topic group a specific thread falls into. This API is in beta and may change without notice. Arguments: - threadId: ID!

Add one or more users or machine users as additional (secondary) assignees on a thread. Additional assignees are looped in but are not the primary person responsible. Requires the `thread:assign` and `thread:read` permissions. Arguments: - input: AddAdditionalAssigneesInput!

Adds a customer to one or more accounts. The customer can be identified by their Plain ID, external ID, or email address. If the customer is already a member of a given account the operation is a no-op for that account. Requires the `customer:edit` and `customerTenantMembership:create` permissions. Arguments: - input: AddCustomerToAccountsInput!

Add a customer to one or more customer groups (up to 25 at once), identified by group ID, key, or external ID. Memberships that already exist are silently skipped, making this operation safe to call repeatedly. Returns only the newly created memberships. Requires `customerGroupMembership:create` permission. Arguments: - input: AddCustomerToCustomerGroupsInput!

Adds a customer to one or more tenants. The customer can be identified by their Plain ID, external ID, or email address. If the customer is already a member of a given tenant the operation is a no-op for that tenant. Requires the `customer:edit` and `customerTenantMembership:create` permissions. Deprecated: Use addCustomerToAccounts instead Arguments: - input: AddCustomerToTenantsInput!

Add one or more team labels to a Plain user (agent). Only label types with type `TEAM` may be applied to users. Label types already present on the user are silently skipped. Requires the `label:create` permission. Arguments: - input: AddLabelsToUserInput!

Adds one or more tenants or companies to a tier (up to 25 per call). Because each tenant or company can belong to only one tier at a time, adding a member that already belongs to another tier will move it to this tier. Requires the `tierMembership:read` and `tierMembership:create` permissions. Arguments: - input: AddMembersToTierInput!

The Sidekick Agent tool approval policies for the workspace: every catalog tool with its effective approval mode (per-workspace override merged over the factory default). Optionally filter to a single service (e.g. "plain"). Arguments: - service: String

Paginated list of the feedback your team has submitted on Plain's AI features, such as a thumbs up or down on a Customer Agent reply, newest first. Use the optional `filters` argument to narrow results by feature, sentiment or submission time. Requires the `aiFeatureFeedback:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: AiFeedbackFilter - first: Int - after: String - last: Int - before: String

Returns the workspace's AI tone rules, which guide how Plain's AI features phrase replies. Use the optional `isEnabled` filter to retrieve only active rules. Pagination is supported via standard `first`/`after` and `last`/`before` cursor arguments, though in practice all rules are returned in a single page. Requires the `aiToneRule:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String - filters: AiToneRulesFilter

Fetch a single autoresponder by its ID. Returns null if no autoresponder with that ID exists. Arguments: - autoresponderId: ID!

List all autoresponders in the workspace, ordered by their configured priority order. Supports cursor-based pagination. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns the available billing plans that can be selected for self-serve checkout. Supports standard forward and backward pagination. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns a paginated list of Slack channels that have opted out of broadcasts, newest first. Requires the `broadcast:read` permission and the broadcasts feature flag. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - searchQuery: String — Narrows to unsubscribes whose connected channel name contains this, or whose Slack workspace name contains this, matched case-insensitively and unanchored. Channel-name matches exclude disconnected channels; a workspace-name match returns every opted-out channel in that Slack workspace, including disconnected ones. - first: Int - after: String - last: Int - before: String

Returns a paginated list of the workspace's broadcasts, newest first. Soft-deleted broadcasts are excluded. Optionally narrow the results with `filters` (status). Supports standard forward and backward cursor pagination. Requires the `broadcast:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: BroadcastsFilter - first: Int - after: String - last: Int - before: String

Instructs the Plain Slack bot to join public Slack channels for the given workspace Slack channel integration. By default it joins every public channel matching an auto-join rule on the integration. Set `rule` to join only the public channels matching one rule, identified by its channel name prefix and suffix. Arguments: - input: BulkJoinSlackChannelsInput!

Applies many connected-slack-channel updates in a single request. Each update is applied independently with the same semantics as `updateConnectedSlackChannel`; partial failures are reported per-item. Arguments: - input: BulkUpdateConnectedSlackChannelsInput!

Applies many Slack per-channel setting writes in a single request. Each update targets the `WORKSPACE_SLACK_CONNECTED_CHANNEL` scope and is written with the same semantics as `updateSetting`. The writes are attempted independently; partial failures are reported per-item. Arguments: - input: BulkUpdateSlackChannelSettingsInput!

Atomically replace all steps in a workflow. Steps with a matching `stepId` are updated; steps without an ID (or with a new ID) are created; steps that existed before but are absent from the input are deleted. Optionally updates `startStepId` and the trigger configuration in the same call. Maximum 60 steps per workflow. Read `workflowBuilderGuide` first for the trigger events and every step payload. Arguments: - input: BulkUpsertWorkflowStepsInput!

Fetches a single business hours override by its ID, or null if no override with that ID exists. Requires the `businessHours:read` permission. Arguments: - businessHoursOverrideId: ID!

Returns a paginated list of business hours overrides across the workspace's schedules, sorted by start date. Filter by schedule, start date or end date. Requires the `businessHours:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: WorkspaceBusinessHoursOverridesFilter - sortBy: BusinessHoursOverridesSort - first: Int - after: String - last: Int - before: String

Fetches a single business hours schedule by its ID, or null if no schedule with that ID exists. Requires the `businessHours:read` permission. Arguments: - businessHoursScheduleId: ID!

Returns a paginated list of the workspace's business hours schedules, sorted by name. Requires the `businessHours:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Calculates the billing cost delta of changing a user's role or seat type, including prorated and full-period amounts. Use this before making a role change to show the user an accurate cost preview. Arguments: - input: CalculateRoleChangeCostInput!

Reassign a thread to a different customer. The original customer retains all their other threads. Requires the `thread:edit` permission. Arguments: - input: ChangeThreadCustomerInput!

Moves a discussion between OPEN and RESOLVED. Callable by a person, by the custom agent a discussion is bound to, or by the machine user that started a Sidekick Agent discussion. Arguments: - input: ChangeThreadDiscussionStatusInput!

Fetch a single chat app by its ID. Returns null if no chat app with that ID exists in the workspace. Requires the `chatApp:read` permission. Deleting a chat app is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/chat/<chatAppId>` (never the `<workspaceId>` placeholder). Arguments: - chatAppId: ID!

List all chat apps in the workspace. Supports cursor-based pagination. Requires the `chatApp:read` permission. Deleting a chat app is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/chat/<chatAppId>` (never the `<workspaceId>` placeholder). Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Check whether a signing secret exists for a chat app. Returns metadata about the secret (creation time, actor) but never the secret value itself — the raw secret is only returned once, at creation time via `createChatAppSecret`. Returns null if no secret has been created for the given chat app. Requires the `chatAppSecret:read` permission. Arguments: - chatAppId: ID!

Returns a paginated list of Discord channels synced from a specific guild. Use `refreshConnectedDiscordChannels` to pull the latest channel list from Discord before querying. Not connected yet? Connecting needs the user's approval in the provider. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/install/discord` (never the `<workspaceId>` placeholder), which takes them straight to Discord to approve, then read this again to confirm. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - discordGuildId: String! - first: Int - after: String - last: Int - before: String

Returns a paginated list of Microsoft Teams channels that are connected to this workspace. Supports forward and backward cursor pagination. Not connected yet? Connecting needs the user's approval in the provider. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/install/ms-teams` (never the `<workspaceId>` placeholder), which takes them straight to Microsoft Teams to approve, then read this again to confirm. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns a single connected Slack channel by its Plain ID, or null if not found. Arguments: - connectedSlackChannelId: ID!

Gets all slack channels for this workspace, which match the specified filters. To count or list the channels a broadcast would reach, use `broadcastSendTargetRecipients` instead: it leaves out channels that unsubscribed. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: ConnectedSlackChannelsFilter - first: Int - after: String - last: Int - before: String

Creates a new account. Fails with a validation error if an account already exists with the provided `externalId`. Use `upsertAccount` instead if you want to create or update an account idempotently. Requires the `tenant:create` permission. Arguments: - input: CreateAccountInput!

Submit feedback on any Plain AI feature result. Pass a JSON-encoded object in the `feedback` field whose `type` discriminates the feature (`AI_AGENT`, `THREAD_CATCHUP`, `THREAD_CLUSTERS`, `TONE_RULE`, or `KNOWLEDGE_GAP`) and includes the relevant context fields and an optional `sentiment` (`POSITIVE`, `NEGATIVE`, or `NEUTRAL`). Arguments: - input: CreateAiFeedbackInput!

Creates a single AI tone rule with the given category and description. Rules are enabled by default; pass `isEnabled: false` to create the rule in a disabled state. A workspace may have at most 7 simultaneously enabled rules across all categories. Requires the `aiToneRule:create` permission. Arguments: - input: CreateAiToneRuleInput!

Create one test thread per scenario for the signed-in user, so they get a populated inbox in a single call rather than one `createTestThread` per scenario. Each thread comes from that scenario's own test customer, and its opening message is written shortly after this returns. Scenarios the caller already has a test thread for are skipped, so calling this again tops the set up rather than duplicating it, and a scenario that fails does not stop the rest. Use `testThreads` for the caller's full set. Requires the `thread:create` permission.

Generate a presigned upload URL for an attachment. Use the returned `uploadFormUrl` and `uploadFormData` fields to POST the file as multipart/form-data directly to storage. The upload URL expires after 2 hours; the resulting `attachment.id` can then be referenced in mutations such as `createThread`, `replyToEmail`, or `createNote`. Requires the `attachment:create` permission. Attachments that are never referenced in a message are automatically deleted after 24 hours. Arguments: - input: CreateAttachmentUploadUrlInput!

Create a new autoresponder that automatically sends a reply when a thread is created from a matching message source and satisfies all specified conditions. A workspace can have at most 25 autoresponders. Requires the `autoresponder:create` permission. Arguments: - input: CreateAutoresponderInput!

Create a new broadcast: a message authored once and posted to many Slack channels at once. Creating one never sends it — a new broadcast is a DRAFT, and scheduling the real send is done by a human in the Plain app. Required input fields: `name`, `content`, `contentFormat`, `type`. - `name` identifies the broadcast internally and is never shown to recipients. It is what `searchBroadcasts` matches on. - `notificationTitle` is what recipients see in the notification the broadcast arrives as. It does leave Plain. Optional here, but the broadcast cannot be sent or tested until it is set. - `type` must be `SLACK`. It is fixed at creation: content is written against a channel's rendering rules, so a broadcast cannot be moved to another channel later. - `contentFormat` and `content` go together. From MCP, send `SLACK_BLOCK_KIT` and a JSON array of Slack blocks, as `chat.postMessage` would take. A one-paragraph body looks like this, passed as a string: "[{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"Hello\"}}]" Buttons need a `url` — interactive elements do nothing in a broadcast. Images must be publicly reachable. This format cannot be edited in the Plain app. `TIPTAP` is still accepted (a serialised Tiptap document) and is what the app composer writes; do not use it unless you are copying content already stored that way. - `isLinkUnfurlingEnabled` controls whether Slack expands links and media. Defaults to true, which is Slack's own behaviour. - `appendUnsubscribeLink` controls whether Plain appends an unsubscribe footer when this broadcast is delivered. Omit to inherit the workspace default from `getBroadcastUnsubscribeLinkSetting`; pass true or false to override that default for this broadcast only. It controls footer emission, not whether unsubscribes are honoured. - `senderType` is who the broadcast is sent as: `PLAIN_WORKSPACE` posts under the workspace's own name and logo and takes no `senderUserId`; `PLAIN_USER` posts as a Plain user and requires `senderUserId`. Get user IDs from `getMyUser` or `getUserByEmail`. Leave `senderEmailAddress` unset: it belongs to a future email channel, not to a Slack broadcast. - `sendTarget` is who the broadcast reaches, resolved to concrete channels at send time. `scope: ALL_RECIPIENTS` means every connected, enabled customer channel and rejects `filters`; `scope: MATCHING` requires `filters`. Omit `scope` to target only the channels named in `recipients`. Inside `filters`, dimensions AND together and values within a dimension OR, and it must constrain something — reaching everyone is `ALL_RECIPIENTS`, not an empty filter. `audienceIds` reference saved audiences (`getBroadcastAudiences`), which must be of the same type as the broadcast. Preview the live resolved set with `getBroadcastSendTargetRecipients`. Both the sender and the target can be left unset here and filled in later with `updateBroadcast`. Use `sendTestBroadcast` to post a test copy to channels you name before a human schedules the real send.

Create a reusable broadcast audience: a named set of broadcast recipients, resolved to concrete Slack channels at send time rather than when saved. Required input fields: `name`, `type`, `filters`. - `name` identifies the audience internally and is never shown to recipients. - `type` must be `SLACK`. It is fixed at creation, and an audience can only be attached to a broadcast of the same type. - `filters` is what the audience selects. Dimensions on one node AND together and values within a dimension OR: `tierIds: [a, b]` means either tier, while `tierIds: [a]` plus `slackChannelNameContains: ["eng"]` means both must hold. An empty dimension cannot be written — omit it instead. - `tenantIds` / `tierIds` — get IDs from `getTenants` or `searchTenants`. - `tenantFields` — filter on a tenant field by its `externalFieldId`, supplying the value field matching the field's type. - `slackChannels` — channels pinned by ID, nothing re-resolves these, so an audience holding only these is a saved channel list. - `slackChannelNameContains` — unanchored, case-insensitive name substrings, ORed with each other and resolved at send time, so channels created or renamed later are picked up. - `and` / `or` / `not` hold further filters. `and` and `or` nest at most two levels deep. `not` may name a single dimension and nothing else. - `audienceIds` is rejected here: an audience cannot be defined in terms of another audience. It is only valid on a broadcast's own send target. - `filters: {}` — no rows at all — means every tenant, and is the only way to say so. Every nested node must constrain something. `filters` is validated against `type`, so a filter naming a dimension this type cannot resolve is rejected here rather than silently resolving to nobody at send time. Editing an audience later changes who every broadcast using it will reach on its next send.

Create an override that replaces a schedule's weekly hours from `startsOn` to `endsOn`, e.g. a holiday. Can't overlap another override on the same schedule. Requires the `businessHours:create` permission. Arguments: - input: CreateBusinessHoursOverrideInput!

Create a new named business hours schedule, optionally with its opening slots. Overlapping and adjacent slots are merged on write. Requires the `businessHours:create` permission. Arguments: - input: CreateBusinessHoursScheduleInput!

Create a new chat app, which represents a source of chat messages (e.g. a specific in-product widget or integration). Optionally supply a `logo` using a previously uploaded workspace file ID. The logo must be a public, image-type workspace file. Requires the `chatApp:create` permission and the live-chat billing entitlement. Arguments: - input: CreateChatAppInput!

Creates a new customer card config. New configs are placed at the bottom of the list (order 100000) by default. A maximum of 25 card configs can be created per workspace. Returns a `too_many_customer_card_configs` error if the limit is reached. The `key` must be unique within the workspace and is used in the request payload sent to your API URL. Arguments: - input: CreateCustomerCardConfigInput!

Creates a customer event that appears in the timeline of every thread belonging to the customer. Use this to surface important product activity (e.g. a failed payment, a deleted API key) so your team has full context when helping the customer. The event layout is defined using Plain UI components. Requires the `customerEvent:create` permission. Arguments: - input: CreateCustomerEventInput!

Create a new customer group with a unique key, display name, and color. Use `upsertCustomerGroup` instead if you need idempotent create-or-update behaviour. Requires `customerGroup:create` permission. Arguments: - input: CreateCustomerGroupInput!

Creates a new customer survey (e.g. a CSAT survey) in the workspace. A survey is sent to the customer when a thread they're on is marked done and matches the survey's conditions, after `responseDelayMinutes`. Requires the `customerSurvey:create` permission and a billing entitlement for customer surveys. You must supply a template (currently only `csatTemplate` is supported) and can optionally specify targeting conditions, an enabled state, a send delay, and a per-customer cooldown interval. Arguments: - input: CreateCustomerSurveyInput!

Creates a new custom role in the workspace. Custom roles inherit the Support permissions by default; set `permissionsPreset` to `VIEWER` for a view-only role that takes a viewer seat rather than a member seat. Thread visibility can be further limited using `upsertRoleScopes`. Requires the `roles:create` permission and the `custom_roles` billing entitlement. Arguments: - input: CreateCustomRoleInput!

Generates a short-lived URL that can be used to preview the rendered HTML of an email. Useful for displaying email content in external tools or dashboards. Arguments: - input: CreateEmailPreviewUrlInput!

Creates a new escalation path with the given name, optional description, and an ordered list of steps (up to 20). Each step routes the thread to either a specific user or the owners of a label type. Steps must not contain duplicates. Requires the `escalationPath:create` permission and the escalation paths feature entitlement. Arguments: - input: CreateEscalationPathInput!

Create a help center with its names, description, type, subdomain, colour and logo. Requires the `helpCenter:edit` permission. Pass each field as its own argument, not wrapped in an `input` object. Custom JavaScript and sign-in can't be set here, because they run code on every public page or take a secret. The user sets them in the Plain app: call `getMyWorkspace` for this workspace's ID and give them the full link with that ID in it, `https://app.plain.com/workspace/w_…/help-center/<helpCenterId>` (never the `<workspaceId>` placeholder).

Create a new article group (folder) within a help center. Pass parentHelpCenterArticleGroupId to nest the group inside an existing group. Requires the helpCenter:edit permission. Arguments: - input: CreateHelpCenterArticleGroupInput!

Manually add a single URL as an indexed document within an existing knowledge source. The document is fetched and queued for indexing asynchronously. Requires Plain AI to be enabled on the workspace; turn it on with `updateSetting` (code `plain_ai`, WORKSPACE scope, boolean `true`). Arguments: - input: CreateIndexedDocumentInput!

Create a new issue in a connected issue tracker (Shortcut, Rootly, incident.io, or GitHub) and return a `ThreadLinkCandidate` that can immediately be used with `createThreadLink` to link it to a thread. The `fields` array must include all required fields for the chosen tracker (use `issueTrackerFields` to discover which fields are required and their allowed values). For GitHub, the acting user must have a personal GitHub user auth integration set up via `createGithubUserAuthIntegration`; the issue is created on their behalf. Requires the `threadLink:create` permission. Arguments: - input: CreateIssueTrackerIssueInput!

Create a new knowledge source that Plain AI will index and use when generating replies. Use type `SITEMAP` to crawl all URLs listed in a sitemap XML file, or type `URL` to index a single page. Requires Plain AI to be enabled on the workspace; turn it on with `updateSetting` (code `plain_ai`, WORKSPACE scope, boolean `true`). Arguments: - input: CreateKnowledgeSourceInput!

Creates a new machine user in the workspace. Each machine user can hold multiple API keys and optionally has a public-facing name shown to customers. Only one machine user of type AI_AGENT is allowed per workspace. Requires the `machineUser:create` permission. Arguments: - input: CreateMachineUserInput!

Report a problem or an idea about Plain's MCP tools to the Plain team. Call this when a tool fails unexpectedly, when you cannot do what the user asked with the available tools, or when you have a concrete idea that would make the tools more useful. Describe the problem in `comment` and name the tool in `toolName` if one was involved. Do not include customer data, personal information, or message content in `comment`. Requires the `aiFeatureFeedback:create` permission. Arguments: - input: CreateMcpFeedbackInput!

Saves a page as a favorite for the currently authenticated user. If the caller has already favorited a page with the same key, the existing record is returned unchanged (idempotent). Requires the `favoritePage:create` permission. Arguments: - input: CreateMyFavoritePageInput!

Creates a new saved threads view in the workspace. The view stores a named filter configuration (including sort order, grouping, layout, and display options) that can be applied when querying threads. Requires the savedThreadsView:create permission; depending on workspace settings, only admins or all members may be allowed to create views. Arguments: - input: CreateSavedThreadsViewInput!

Create a service level agreement (SLA) for a tier. Each SLA commits your team to a time target and can be scoped by thread priority and/or label type. Provide exactly one of `firstResponseTimeMinutes` (time from thread creation to first reply), `nextResponseTimeMinutes` (time from each customer message to the next reply), `firstResolutionTimeMinutes` (time from thread creation to first Done), or `totalResolutionTimeMinutes` (time from thread creation to Done, including after reopen). A `nextResponseTimeMinutes` SLA can only be created if a `firstResponseTimeMinutes` SLA already exists on the same tier. Requires the `serviceLevelAgreement:create` permission. Arguments: - input: CreateServiceLevelAgreementInput!

Create an SLA policy together with its targets. A policy holds at most one target per type, and any combination of types is valid. Business hours schedules are chosen once per policy: every target that uses business hours must reference the same schedules, and a target with none is tracked 24/7. A policy only starts tracking once it is applied to a thread. Requires the `serviceLevelAgreement:create` permission. Arguments: - input: CreateServiceLevelAgreementPolicyInput!

Create a new task in Plain. Only `title` is required. Optional fields: - `description`: longer context or instructions for the task. - `status`: TODO (default), IN_PROGRESS, DONE, or CANCELLED. - `priority`: 0 (urgent), 1 (high), 2 (normal, default), or 3 (low). - `accountId`: the account this task relates to. - `assignedTo`: provide either `userId` or `machineUserId`, not both. To link the new task to a thread, pass the returned task `id` to `createThreadLink` as `plainTask: { plainTaskId }`.

Creates a new tenant. Fails with a validation error if a tenant already exists with the provided `externalId`. Use `upsertTenant` instead if you want to create or update a tenant idempotently. Requires the `tenant:create` permission. Deprecated: Use createAccount instead Arguments: - input: CreateTenantInput!

Create a test thread for the signed-in user. Test threads come from a test customer rather than a real one. The scenario is picked for you and fixes the thread's title; its opening message is written shortly after this returns. They are listed by `testThreads` rather than `threads`, and only for the user who created them. Pass `channel: SLACK` to have the conversation happen in the workspace's Slack test channel instead of chat, so the caller sees a thread arrive the way a customer's Slack message does. Requires the `thread:create` permission. Arguments: - input: CreateTestThreadInput

Start a new discussion on a Plain thread. Supports Slack (posts a new thread in a connected Slack channel), Email (sends an outbound email chain), and Cursor workspace background agent discussions. The markdownContent field is sent as the opening message; for Slack discussions you may also supply slackBlocks (JSON-encoded Block Kit array) for rich Slack formatting while markdownContent serves as the Plain UI fallback. Prefer createDiscussion for new integrations. Arguments: - input: CreateThreadDiscussionInput!

Creates a thread event that appears only in the timeline of the specified thread. Use this when an activity is specific to a single conversation rather than the customer as a whole. The event layout is defined using Plain UI components. Thread events are visible only to your team and are never shown to the customer. Requires the `threadEvent:create` and `threadEvent:read` permissions. Arguments: - input: CreateThreadEventInput!

Creates a thread from a message in a Microsoft Teams channel or chat that the Plain bot is a member of. This is the trigger for the `API_ONLY` value of the `ms_teams/ingestion_mode` workspace setting, and works in `AUTOMATIC` mode too. In a channel, the whole post the message belongs to becomes the thread. In a chat, the thread also includes the messages before and after this one, taken from the chat's 50 most recent messages. Thread creation runs asynchronously, so `thread` is only returned when the message was already on a thread. Requires the `thread:create` permission. Arguments: - input: CreateThreadFromMSTeamsMessageInput!

Creates a thread from a top-level message in a connected customer Slack channel, along with the replies Plain has already received for it. This is the trigger for the `API_ONLY` ingestion mode, and works in every other mode too. Ingestion runs asynchronously, so `thread` is returned only when the message had already been ingested. Requires the `thread:create` permission. This is not a way to import historic conversations: only replies Plain saw over the Slack events API are included, so a message from before the Plain bot joined the channel becomes a thread missing everything that was said before then. Arguments: - input: CreateThreadFromSlackMessageInput!

Creates a new tier. You can optionally add tenant and company members at creation time. Requires the `tier:create` permission. Arguments: - input: CreateTierInput!

Create a new workflow. The workflow starts unpublished with no steps; use `bulkUpsertWorkflowSteps` to add steps and `updateWorkflow` to publish it. The `trigger` field must be a valid JSON-encoded trigger configuration. Read `workflowBuilderGuide` first for the trigger events and every step payload. Arguments: - input: CreateWorkflowInput!

Add a single step to a workflow. For bulk changes to a workflow's step graph, prefer `bulkUpsertWorkflowSteps`. `workflowBuilderGuide` lists every step payload. Arguments: - input: CreateWorkflowStepInput!

Generate a fresh download URL for a workspace file. For PRIVATE files, returns a short-lived pre-signed URL (valid for 3 minutes); for PUBLIC files, returns a permanent CDN URL with no expiry. Call this whenever you need to give a user access to a file rather than caching URLs, as private URLs expire quickly. Arguments: - input: CreateWorkspaceFileDownloadUrlInput!

Begin a two-step file upload. Returns a pre-signed S3 form URL and form data fields that you POST the raw file bytes to directly from the client. The upload URL expires in 2 hours. Files must be 50 MB or smaller; certain executable file extensions (e.g. .exe, .bat) are rejected. Requires the `workspaceFile:create` permission. Arguments: - input: CreateWorkspaceFileUploadUrlInput!

Connect workspace Slack notifications using a Slack connection the workspace already has. There is no second OAuth install. Pass the id of an existing workspace Slack channel integration (`workspaceSlackChannelIntegrations`). Requires `workspaceSlackIntegration:create`. This does not choose the channel notifications post to, and it does not start posting. After it succeeds, set the `notification/slack/channel_id` setting on the new integration. Until that setting is present, Plain drops workspace Slack notifications for it.

Returns the list of GitHub repositories accessible via the given Cursor integration. Results are fetched live from the Cursor API and cached for up to 5 minutes. Requires the `workspaceCursorIntegration:read` permission. Arguments: - integrationId: ID!

Fetch a customer by their email address. Returns null if no customer with that email exists. Requires the `customer:read` permission. Arguments: - email: String!

Get a customer by its external ID. A customer's external ID is unique within a workspace. Arguments: - externalId: ID!

Returns a single customer card config by ID. Returns null if no config with the given ID exists. Deleting a card is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/customer-cards/<customerCardConfigId>` (never the `<workspaceId>` placeholder). Arguments: - customerCardConfigId: ID!

Returns all customer card configs for the workspace, ordered by their `order` field. Deleting a card is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/customer-cards/<customerCardConfigId>` (never the `<workspaceId>` placeholder).

Returns the current customer card instances for a customer, triggering a fresh load for any cards that are expired or in an error state. Cards that are cached and within their TTL are returned immediately as `CustomerCardInstanceLoaded`. Cards that need to be fetched are returned as `CustomerCardInstanceLoading`; subscribe to `customerCardInstanceChanges` to receive the result when loading completes. Pass `threadId` to provide thread context to your card API endpoint. A maximum of 25 card instances will be returned, due to only allowing 25 customer card configs. Arguments: - customerId: ID! - threadId: ID

Fetch a single customer group by its ID. Returns null if no group with the given ID exists in the workspace. Arguments: - customerGroupId: ID!

Fetch a paginated list of all customer groups in the workspace. Optionally filter by external IDs using the `filters` argument. Uses cursor-based pagination. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: CustomerGroupsFilter - first: Int - after: String - last: Int - before: String

Fetch a paginated list of all customers in the workspace. Supports filtering by group membership, company, spam status and more via `filters`, and ordering via `sortBy`. Use cursor-based pagination (`first`/`after` or `last`/`before`) to page through large result sets. Requires the `customer:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: CustomersFilter - sortBy: CustomersSort - first: Int - after: String - last: Int - before: String

Fetches a single customer survey by its ID. Returns null if no survey with that ID exists. Arguments: - id: ID!

Returns a paginated list of all customer surveys configured in the workspace, ordered by their display order. Use this to build management UIs or sync survey configurations. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns a single custom role by its ID, or null if not found. Requires the `roles:read` permission. Changing a role's permissions or which threads it can see is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/roles/<customRoleId>` (never the `<workspaceId>` placeholder). Arguments: - customRoleId: ID!

Returns all custom roles defined in the workspace. Use this to list the custom roles you have created and inspect their scope definitions. Supports cursor-based pagination. Requires the `roles:read` permission. Changing a role's permissions or which threads it can see is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/roles/<customRoleId>` (never the `<workspaceId>` placeholder). Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Dismisses one or more pending suggested label types without creating label types. All ids must currently be PENDING. Requires the `labelType:create` permission. Arguments: - input: DismissSuggestedLabelTypesInput!

Copy an existing broadcast into a new DRAFT. Authoring fields (name prefixed with "Copy of", content, audience, sender, notification title, and related settings) are copied. Send history, schedule, recipients, and delivery stats are not — the copy is never scheduled or sent by this mutation. Returns the new draft's identity only. Call `getBroadcastDetails` with the returned id to read the copied content, sender, and audience. Requires `broadcast:create` and `broadcast:read`. Use `updateBroadcast` and `scheduleBroadcast` on the returned id if the draft should go out.

Edits the text of a user message that is waiting in a Sidekick Agent AGENT_SESSION queue. Attachments are not editable in this flow — delete and re-send to change them. Rejects with `queued_agent_session_message_already_dispatched` if the agent has already picked the message up. Arguments: - input: EditQueuedAgentSessionMessageInput!

Returns the suppression for a specific email address, or null when the address is not suppressed. Arguments: - emailAddress: String!

Returns all currently enabled AI tone rules serialised as a plain-text instruction string that is suitable for injecting into AI prompts. Returns `null` when no rules are enabled or the feature flag is off. Requires the `aiToneRule:read` permission.

Advance a thread to the next step in its escalation path. The thread must already have an escalation path attached (via `updateThreadEscalationPath`) — if not, this call returns an error. Requires the `thread:edit` permission. Arguments: - input: EscalateThreadInput!

Fetches a single escalation path by its ID. Returns null if no escalation path with the given ID exists. Requires the `escalationPath:read` permission. Arguments: - id: ID!

Returns a paginated list of all escalation paths configured in the workspace. Requires the `escalationPath:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Build the files for publishing a workflow as a template; writes nothing. Requires the `workflowRule:create` permission. Arguments: - input: ExportWorkflowTemplateInput!

Create a new thread by forking from a specific timeline entry in an existing thread. The forked thread starts at the chosen message, allowing you to split a conversation into a separate support case. Requires the `thread:create` permission. Arguments: - input: ForkThreadInput!

Uses AI to generate a set of tone rules from a free-text description of the desired communication style (up to 5000 characters). The generated rules are saved to the workspace in a disabled state so you can review and selectively enable them. Returns the newly created rules. Requires the `aiToneRule:create` permission. Arguments: - input: GenerateAiToneRulesFromDescriptionInput!

This API is in beta and may change without notice. Returns the current suggested reply candidates for a thread, scoped to the most recent inbound message from the customer or from a machine user. Suggestions submitted via `addGeneratedReply` are always included. Suggestions generated by Plain AI are excluded when suggested responses are disabled or not available for the workspace, or when an externally submitted suggestion exists for the same message. Returns an empty list if the thread has no such message or no suggestion is available. Requires the `generatedReply:read` permission. Arguments: - threadId: ID! - options: [GenerateReplyOption!]

Use AI to generate one or more draft help center articles from the content of a support thread. Returns the generated articles in DRAFT status for review before publishing. Requires the helpCenter:edit permission. Arguments: - input: GenerateHelpCenterArticleInput!

Fetch a single broadcast audience by its ID, or null if no audience with that ID exists. Returns soft-deleted audiences (where `isDeleted` is true), so the record of what a past broadcast was sent to survives. In `filters`, dimensions on one node AND together and values within a dimension OR. `slackChannels` are channels pinned by ID; the `slackChannelNameContains` substrings are re-resolved at send time. An audience with no filters at all means every tenant. `type` is fixed at creation and must match the type of any broadcast the audience is attached to. Audience IDs start with `ba_`. Do not invent IDs — only use values returned by the MCP tools.

Fetch a paginated list of the workspace's broadcast audiences, newest first. An audience is a named, reusable set of broadcast recipients, resolved to concrete Slack channels at send time rather than when it was saved. Soft-deleted audiences are excluded. Pass `searchQuery` to narrow to audiences whose name contains it, matched case-insensitively and unanchored. The match happens in the database, so it finds audiences that are not on the current page. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 50). In `filters`, dimensions on one node AND together and values within a dimension OR: `tierIds: [a, b]` means either tier, while `tierIds: [a]` plus `slackChannelNameContains: ["eng"]` means both must hold. `slackChannels` are channels pinned by ID, so an audience holding only those is a saved channel list. `slackChannelNameContains` is re-resolved at send time, so it picks up channels created or renamed since. An audience with no filters at all means every tenant. An audience's own filters never contain `audienceIds` — an audience cannot be defined in terms of another one. Audience IDs start with `ba_`. Do not invent IDs — only use values returned by the MCP tools.

Fetch a single broadcast by its ID, including its authored content and who it is targeted at. Returns null if no broadcast with that ID exists, and returns soft-deleted broadcasts (where `isDeleted` is true). `content` is encoded as `contentFormat` says: `TIPTAP` is a serialised Tiptap JSON document (what the Plain app writes); `SLACK_BLOCK_KIT` is a JSON array of Slack blocks. Neither is plain text or markdown. `sendTarget` is who the broadcast reaches, resolved to concrete channels at send time rather than now. `scope: ALL_RECIPIENTS` means every connected, enabled customer channel and carries no `filters`; `scope: MATCHING` means only what `filters` selects. `recipients` are channels named outright and added to whatever `filters` resolves to; `excludeRecipients` are subtracted last. Inside `filters`, dimensions on one node AND together and values within a dimension OR. `audienceIds` reference saved audiences — read them with `getBroadcastAudienceDetails`. Preview the live resolved set with `getBroadcastSendTargetRecipients`. `appendUnsubscribeLink` is the per-broadcast override for whether Plain appends an unsubscribe footer when this broadcast is delivered. Null inherits the workspace default from `getBroadcastUnsubscribeLinkSetting`; true or false overrides that default for this broadcast only. It controls footer emission, not whether unsubscribes are honoured. `latestSend` is the most recent non-test send, and where progress lives. Use `getBroadcastSends` for the full send history, and `getBroadcastSendDeliveries` for the recipients of one send. Broadcast IDs start with `bc_`, audience IDs with `ba_`. Broadcast URL format: https://app.plain.com/workspace/{workspaceId}/broadcasts/{broadcastId} where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`). Do not invent IDs — only use values returned by the MCP tools.

Fetch a paginated list of Slack channels that have opted out of broadcasts, newest first. Use this to answer "is this channel unsubscribed?" or to audit who will be skipped on the next send. An unsubscribe is global per channel: the channel is excluded from every broadcast audience until someone resubscribes it. That is a different reason for missing a send than "the filter never matched" — check this list (or `getBroadcastSendTargetRecipients` / `SKIPPED_UNSUBSCRIBED` deliveries) before concluding a filter is wrong. Optionally narrow with `searchQuery`: matched case-insensitively and unanchored against the connected channel's current name or the Slack workspace (team) name. A channel-name hit only includes currently connected channels. A workspace-name hit returns every opted-out channel in that Slack workspace, including disconnected ones (`connectedSlackChannel` null). Disconnected channels also appear when listing without a query. Omit `searchQuery` rather than passing an empty string. A search hit is not proof the named channel is unsubscribed. Inspect each row: treat it as that channel only when `connectedSlackChannel.name` matches (after stripping a leading `#`) or `slackChannelId` matches. Other rows are siblings from a workspace whose name contained the query — do not report those as the channel the user asked about. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 50). To remove an unsubscribe, call `resubscribeBroadcastRecipient` with the same `slackTeamId` + `slackChannelId`. To add one, call `unsubscribeBroadcastRecipient`. Unsubscribe IDs start with `bru_`. Do not invent IDs — only use values returned by the MCP tools.

Fetch a paginated list of the workspace's broadcasts, newest first. A broadcast is a message authored once and posted to many Slack channels at once. Soft-deleted broadcasts are excluded from this list. Optionally narrow the list with `statuses`, e.g. ["DRAFT"] for broadcasts still being written or ["SENT"] for ones already delivered. A broadcast's status comes from its latest real send, so no status reflects a test send. Omit `statuses` to list every status — an empty list is rejected. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 50). `appendUnsubscribeLink` is the per-broadcast override for the unsubscribe footer (null inherits `getBroadcastUnsubscribeLinkSetting`). `latestSend` is the most recent non-test send and is where progress lives — read `deliveryCounts` from it rather than counting deliveries. `skippedUnsubscribed` is channels matched at resolve time but not posted because they opted out; it is not part of `total`. Use `getBroadcastSends` for a broadcast's full send history, and `getBroadcastSendDeliveries` for the recipients of one send. Broadcast IDs start with `bc_`. Broadcast URL format: https://app.plain.com/workspace/{workspaceId}/broadcasts/{broadcastId} where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`). Do not invent IDs — only use values returned by the MCP tools.

Fetch the individual recipients of one broadcast send — which channel got the message, which did not, and why. Use this to answer "who missed it" or "did this channel get it". A delivery is one recipient's copy of the broadcast within one send. Narrow with `deliveryStatuses`, e.g. ["FAILED"], ["SENT"], or ["SKIPPED_UNSUBSCRIBED"]. `SKIPPED_UNSUBSCRIBED` means the channel matched the audience at send time but was not posted because it had opted out — that is a different reason for missing the message than a filter that never matched, or a `FAILED` delivery with a `failureReason`. Read `failureReason` for why a `FAILED` delivery did not land. Combine with `searchQuery` to find one recipient: matched case-insensitively and unanchored against the recorded Slack channel name, the Slack channel id, and the email address, so a delivery is found by whichever of those identifies it. The match happens in the database, so it finds deliveries that are not on the current page. Omit `searchQuery` rather than passing an empty string. `slackChannelName` is the name recorded when the send resolved, so it still names a channel that was later renamed or disconnected; it is null for deliveries from before the name was recorded. This reads the send named by `broadcastSendId`. Get the id from `getBroadcastSends`; use `isTest` to distinguish test from real sends there. An id belonging to another broadcast matches nothing. `cursor` and `first` page that send's deliveries. Use the endCursor from the previous response's `deliveries.pageInfo`; it stays valid because every page selects the same send. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. `deliveryCounts` on the send is the unfiltered summary of the whole send. `skippedUnsubscribed` is not part of `total`. `deliveries.totalCount` is how many rows match `deliveryStatuses` and `searchQuery`. A broadcast with hundreds of recipients has hundreds of deliveries, so prefer the counts plus a `deliveryStatuses: ["FAILED"]` or `["SKIPPED_UNSUBSCRIBED"]` query over paging the whole list. `edges` is empty when the broadcast has no send with that id. For the full send history use `getBroadcastSends`. For the live opted-out list independent of any send, use `getBroadcastRecipientUnsubscribes`. Broadcast IDs start with `bc_`, send IDs with `bcs_`, delivery IDs with `bcsd_`. Do not invent IDs — only use values returned by the MCP tools.

Fetch the send history of one broadcast, newest first. Use this to answer "has this broadcast gone out, and how far did each run get". One send is one run of the broadcast. A broadcast that has been sent once and tested twice has three sends. Test sends post real messages and collect real deliveries, so check `isTest` before presenting an entry as a real send, or pass `isTest: false` to exclude them. `statuses` narrows to sends in particular states; `DRAFT` is not one of them, since it describes a broadcast with no send rather than a send. Omit a filter to leave that dimension unconstrained — an empty list is rejected. `deliveryCounts` is how far a send got, summarised across its recipients. It is one query per send regardless of how many recipients there are, so read it rather than counting recipients. `skippedUnsubscribed` is channels matched at resolve time but not posted because they opted out; it is recorded separately and is not part of `total`. For the individual recipients of one send — which channel got it, which failed and why, which were skipped as unsubscribed — use `getBroadcastSendDeliveries`. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 20). Broadcast IDs start with `bc_`, send IDs with `bcs_`. Do not invent IDs — only use values returned by the MCP tools.

Preview who a broadcast send target resolves to right now — the live filter-to-recipient count, not a past send. Use this to answer "how many channels would get this?" and "why is the count zero?" before a human schedules the real send. Point-in-time: the number moves as tenants, tiers, tenant fields and connected channels change. Resolved through the same path a send uses, so it is what would actually be delivered to rather than an estimate assembled another way. Unsubscribed channels are excluded from `count` the same way a real send excludes them. Required input: `type` (must be `SLACK`) and `sendTarget`. - `sendTarget.scope: ALL_RECIPIENTS` means every connected, enabled customer channel and rejects `filters`. `scope: MATCHING` requires `filters`. Omit `scope` to target only channels named in `recipients`. - Inside `filters`, dimensions on one node AND together and values within a dimension OR. `audienceIds` reference saved audiences (`getBroadcastAudiences`). - `recipients` are channels named outright and added to whatever `filters` resolves to; `excludeRecipients` are subtracted last. When `count` is zero, read `emptyReason` before guessing — and treat an opt-out as a real possibility even when the reason is not `ALL_RECIPIENTS_UNSUBSCRIBED`: - `NO_TENANTS_MATCHED` — the filter itself matched no tenants. - `NO_RECIPIENTS_RESOLVED` — nothing reachable remained. That includes disabled / disconnected channels, and also every pin-by-id match (`filters.slackChannels` or named `recipients`) having opted out. Name / tenant filters usually surface the same opt-out as `ALL_RECIPIENTS_UNSUBSCRIBED` instead. Before telling the user a named channel is unreachable, call `getBroadcastRecipientUnsubscribes` (or resubscribe and re-preview) — an opt-out is not a broken connection. - `EXCLUDED_BY_AUDIENCE` — something matched, then the target's own exclusions removed all of it. - `ALL_RECIPIENTS_UNSUBSCRIBED` — something matched, and every channel it would have reached has opted out. That is not a broken filter; list the opted-out channels with `getBroadcastRecipientUnsubscribes` and restore one with `resubscribeBroadcastRecipient` if appropriate. `recipients` pages the channels that remain after unsubscribes are excluded. Use `searchQuery` to find one by name without changing `count`. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. For a broadcast that has already sent, prefer `getBroadcastSendDeliveries` with `deliveryStatuses: ["SKIPPED_UNSUBSCRIBED"]` and the send's `deliveryCounts.skippedUnsubscribed` — those record what happened at send time rather than a live preview.

Read whether this workspace appends an unsubscribe link to outgoing broadcasts by default. This is emission-only: it controls whether the footer link is rendered on delivered messages. It does not enable or disable unsubscribes themselves — channels can still be opted out via `unsubscribeBroadcastRecipient` or the public link, and audience resolution always honours existing unsubscribes regardless of this setting. Precedence when a broadcast is delivered: 1. If the broadcast has an explicit `appendUnsubscribeLink` override, that value wins for that broadcast only. 2. Otherwise this workspace default applies. Null on the broadcast means "inherit this setting". The default for a new workspace is false (no footer). Read a broadcast's own override with `getBroadcastDetails`.

Fetch a specific knowledge gap by its ID, including its task and the threads where customers hit it. Each signal's `threadId` is a thread where Ari could not answer the customer; pass it to `getThreadDetails` to read the question. Use `signalsCursor` with the endCursor from the previous response's signals pageInfo to fetch more signals. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. To close a gap: check `searchKnowledgeSources` for existing content, draft or improve it (e.g. via `upsertHelpCenterArticle`), then set the gap's task to DONE with `updateTask`. If the gap is not worth addressing, set the task to CANCELLED instead.

Fetch knowledge gaps: questions customers ask that Ari, Plain's AI agent, could not answer from the workspace's knowledge sources. Each gap is detected from Ari replies and has a task raised for it; the gap's status follows that task's status. By default, returns only open gaps (TODO, which includes IN_PROGRESS tasks), most frequently hit first. To include all gaps, pass statuses: null. To see the most recently hit gaps, pass sortBy: { field: LAST_SEEN_AT, direction: DESC }. To scope to a time window, pass `lastSeenAt` with ISO 8601 bounds, e.g. { after: "2026-10-12T00:00:00Z" } for gaps hit at least once since then. `signals.totalCount` is how many times customers have hit the gap, all time, even when `lastSeenAt` is set. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 25). Pass a gap's `id` to `getKnowledgeGapDetails` for the threads that hit it.

Fetch the workspace's knowledge sources: the sitemaps and single URLs that Plain indexes for Ari and other AI features. Each source's `status` shows whether it is pending, indexed (with `indexedAt`), or failed (with a `reason`). Sitemaps also include counts of their crawled pages by status, so a sitemap can be indexed overall while some pages failed. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 25). To pick up changes to a source's content without waiting for the automatic weekly reindex, pass its `id` to `reindexKnowledgeSource`.

Fetches the current members of a Microsoft Teams channel directly from the Teams API. Requires a workspace MS Teams integration and calls Microsoft Graph; use this to populate member lists when resolving customers for a channel. Arguments: - msTeamsChannelId: ID! - msTeamsTeamId: ID!

Fetch tasks assigned to a specific user in Plain. Pass the authenticated user's ID (from `getMyUser`, starts with `u_`) as `userId`. By default, returns only open tasks (TODO and IN_PROGRESS), highest priority first. To include all tasks regardless of status, pass statuses: null. To filter by specific statuses, pass an array like statuses: [TODO, DONE]. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 25). Task URL format: https://app.plain.com/workspace/{workspaceId}/tasks/{ref}/ where {ref} is the task `ref` field on each result (e.g. `T-123`) and {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`). Do not invent IDs. Only use values returned by the MCP tools.

Fetch detailed information about a specific task by its ID. If you only have the human-readable ref shown in the Plain app (e.g. `T-123`), use `getTaskDetailsByRef` instead. Returns the task's status, priority, account, assignee, the threads linked to it, and the entities that raised it (e.g. a knowledge gap). Use `threadLinksCursor` with the endCursor from the previous response's threadLinks pageInfo to fetch more linked threads. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Linked threads only carry a `threadId`; pass it to `getThreadDetails` for the thread's title, status, and context. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`).

Fetch detailed information about a specific task by its human-readable ref, as displayed in the Plain app (e.g. `T-123`). Returns the task's status, priority, account, assignee, the threads linked to it, and the entities that raised it (e.g. a knowledge gap). Use `threadLinksCursor` with the endCursor from the previous response's threadLinks pageInfo to fetch more linked threads. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Linked threads only carry a `threadId`; pass it to `getThreadDetails` for the thread's title, status, and context. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`).

Fetch a paginated list of tasks in the workspace. By default, returns only open tasks (TODO and IN_PROGRESS), most recently updated first. To include all tasks regardless of status, pass statuses: null. Narrow results with `assignedToUserIds` (user IDs, starting with `u_`), `isAssigned`, or `accountIds`. Change ordering with `sortBy`, e.g. { field: PRIORITY, direction: ASC } (lower priority numbers are more urgent). For tasks assigned to the authenticated user, prefer `getMyAssignedTasks`. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 25). Task URL format: https://app.plain.com/workspace/{workspaceId}/tasks/{ref}/ where {ref} is the task `ref` field on each result (e.g. `T-123`) and {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`). Do not invent IDs. Only use values returned by the MCP tools.

Returns the GitHub user authentication integration for the currently authenticated user, or null if no integration exists.

Fetch a single help center by ID. Returns null if not found. Arguments: - id: ID!

Fetch a single help center article by ID. Returns null if not found. Deleting an article is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/help-center/<helpCenterId>/articles/<articleId>` (never the `<workspaceId>` placeholder). Arguments: - id: ID!

Fetch an article by its URL slug within a specific help center. Slugs are unique per help center. Returns null if no article matches. Arguments: - helpCenterId: ID! - slug: String!

Fetch a single article group by ID. Returns null if not found. Arguments: - id: ID!

Fetch an article group by its URL slug within a specific help center. Returns null if no group matches. Arguments: - helpCenterId: ID! - slug: String!

Fetch the navigation index for a help center by its ID: every heading, article group and article in sidebar order, with its type, id, parent and title. Returns null if not found. A large help center's index is returned in one response, so this keeps to what an index needs. Read an article's slug, description or content with `helpCenterArticle`. To change the index, pass the returned `hash` to `updateHelpCenterIndex` with every item as `{ type, entityId: id, parentId, title }`. The call fails if the index changed since you read it; read it again and reapply your change.

List all help centers in the workspace. Supports cursor-based pagination and optional filtering. Custom JavaScript, sign-in, access, the type and the subdomain of an existing help center are set by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/help-center/<helpCenterId>` (never the `<workspaceId>` placeholder), or `…/help-center/create` for a new help center that needs them. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String - filters: HelpCentersFilter

Fetch the import job definition for a connected service integration. Pass isEnabled: true to return only the currently active definition, or isEnabled: false to return any definition regardless of enabled state. Returns null if no matching definition exists. Arguments: - serviceIntegrationKey: String! - isEnabled: Boolean

List import jobs, optionally filtered by service integration key or import job definition ID. Each job is a single sync run of an import job definition, with a run per entity type showing its progress, status and timing. Each job carries its whole run history, so a page holds 10 jobs unless you pass a different `first`. Page on with `after`.

List indexed documents across your workspace, newest first. Use the `knowledgeSourceId` filter to retrieve only the documents belonging to a specific knowledge source, and the `statuses` filter to retrieve only documents with a given ingestion status. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String - filters: IndexedDocumentsFilter

List the static variables that can be interpolated with `{{ key }}` in snippets, auto-responses, bulk replies and workflow actions, with a label and group for building a picker. Thread field variables are not included; derive them from the thread field schemas as `threadField.<key>`. Requires the `workspace:read` permission.

Fetch the configurable fields for a connected issue tracker (e.g. Shortcut, Rootly, incident.io, GitHub). Pass previously selected field values in `selectedFields` so that dependent fields (such as labels that depend on a chosen repository) are populated correctly. Returns the list of fields the caller must or may provide when calling `createIssueTrackerIssue`. Requires the `threadLinkCandidate:search` permission. Arguments: - issueTrackerType: String! — One of `github_issue`, `shortcut_issue`, `incidentio_incident` or `rootly_incident`. - selectedFields: [SelectedIssueTrackerField!]!

Fetch a single knowledge source by its ID. Returns null if no knowledge source with the given ID exists. Arguments: - knowledgeSourceId: ID!

Returns the knowledge sources cited by AI agent replies across a thread, each linked to the timeline entry it was cited in and carrying a snapshot title (and best-effort url) plus the live cited document when it still exists. Returns an empty list when the thread has no citations or is not visible to the caller. Requires the `thread:read` and `timeline:read` permissions. Arguments: - threadId: ID!

List all knowledge sources in the workspace. Use the `type` filter to retrieve only sitemap or single-URL sources. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String - filters: KnowledgeSourcesFilter

Returns a single label type by its ID. Returns null if no label type with that ID exists. Requires the `labelType:read` permission. A team's assignment settings, such as its round-robin capacity, come from `teamSettings`. Arguments: - labelTypeId: ID!

Returns a label type by its external ID. Returns null if no match is found. External IDs are unique within a workspace and are set when creating or updating a label type. Requires the `labelType:read` permission. Arguments: - externalId: ID!

The workspace-level Linear app integration, if one has been authorised. Not connected yet? Connecting needs the user's approval in the provider. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/install/linear` (never the `<workspaceId>` placeholder), which takes them straight to Linear to approve, then read this again to confirm.

Lock a thread to prevent further replies or changes by non-admin users. Use this when a resolution is final and you want to freeze the conversation. Requires the `thread:edit` permission. Arguments: - input: LockThreadInput!

Fetches a single machine user by ID. Returns null if no machine user with the given ID exists in the workspace. Its API keys and their permissions come from `machineUserApiKeys`, which needs the `apiKey:read` permission. Deleting a machine user, and creating, changing or deleting its API keys, are done by the user in the Plain app, so a key's secret never passes through an agent. Call `getMyWorkspace` for this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/machine-users/<machineUserId>`, or `…/api-keys/add` and `…/api-keys/<apiKeyId>` under it for keys (never the `<workspaceId>` placeholder).

Lists a machine user's API keys with each key's permissions. Requires the `apiKey:read` permission. Creating, changing and deleting API keys are done by the user in the Plain app, so a key's secret never passes through an agent. Call `getMyWorkspace` for this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/machine-users/<machineUserId>/api-keys/add`, or `…/api-keys/<apiKeyId>` for an existing key (never the `<workspaceId>` placeholder), then read this again to confirm.

Returns a paginated list of all machine users in the workspace. Use the optional `filters.type` argument to restrict results to a specific machine user type (e.g. API_USER or AI_AGENT). Deleting a machine user, and creating, changing or deleting its API keys, are done by the user in the Plain app, so a key's secret never passes through an agent. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/machine-users/<machineUserId>` (never the `<workspaceId>` placeholder), or `…/api-keys/add` and `…/api-keys/<apiKeyId>` under it for keys. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: MachineUsersFilter - first: Int - after: String - last: Int - before: String

Flag a customer as spam. This hides their threads from the inbox and excludes them from metrics. Marking a customer that is already marked as spam returns a `customer_already_marked_as_spam` error. Pass the customer `id` (starts with `c_`) as `customerId`. Use `getCustomers`, `searchCustomers`, or `getCustomerDetails` to discover it.

Clear the unread flag on a discussion. Use this when the user has viewed a discussion so that the isUnread indicator is reset. Returns the updated discussion. Arguments: - input: MarkThreadDiscussionReadInput!

Move a workflow so it sits directly after another, or to the front of the list when `afterWorkflowId` is null. Only the moved workflow changes. Arguments: - input: MoveWorkflowInput!

Returns the current billing rota for the workspace, listing which users are actively on-rota and which are off-rota. The rota is used to track which users currently consume an active eng-rota seat.

Returns the current workspace billing subscription, including plan, status, trial info, feature entitlements, and credit balances. Returns null if the workspace has no billing account.

Returns the email signature configured for the currently authenticated user, or null if none has been set.

Returns the favorite pages saved by the currently authenticated user, ordered by most recently created first. Each user's favorites are independent — this query only returns pages belonging to the caller. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns a paginated list of internal notifications for the currently authenticated user. Use the optional `filters` argument to narrow results by read status or creation time. Supports forward and backward cursor-based pagination via `first`/`after` and `last`/`before`. Only available to human users — machine users will receive a forbidden error. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: InternalNotificationsFilter - first: Int - after: String - last: Int - before: String

Returns the current user's Linear integration, or null if no integration has been set up.

Returns the Microsoft Teams integration for the currently authenticated user, or null if the user has not connected their account.

Returns the full list of permission strings granted to the currently authenticated user or machine user in this workspace. Useful for inspecting what actions the caller is authorized to perform.

Returns the current user's personal Slack notifications integration, or null if none is connected.

Returns the UserAccount for the currently authenticated user, or null if no account has been created yet. Useful during onboarding to check whether account setup is complete.

Returns all pending workspace invites sent to the currently authenticated user's email address. Use this to let a user see and act on workspaces they have been invited to join. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns all workspaces the currently authenticated human user belongs to, paginated. Not available to machine users. Use this to let users switch between workspaces. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Returns the complete list of all permission strings defined in Plain, sorted alphabetically. Use this to discover valid permission values when building role or API key management UIs. Requires the `permission:read` permission.

Syncs the list of Discord channels for a guild from the Discord API into Plain. Call this after channels are added or renamed in Discord so that `connectedDiscordChannels` reflects the latest state. Arguments: - input: RefreshConnectedDiscordChannelsInput!

Reindex a knowledge source now instead of waiting for the automatic weekly reindex, e.g. after its pages were updated to fill a knowledge gap or after a failed index. Pass the source's `id` from `getKnowledgeSources`, or a search result's `knowledgeSourceId` from `searchKnowledgeSources`. Indexing runs in the background: the source returns as pending, and `getKnowledgeSources` shows when it is indexed or failed. For sitemaps, only new or changed pages are reprocessed, and pages no longer in the sitemap are removed. Requires Plain AI to be enabled on the workspace.

Find threads that are semantically similar to the given thread, ranked by relevance. Each result includes the thread and a distance score (lower means more similar). Useful for surfacing related support history or finding duplicate issues. Requires the `thread:read` permission. Arguments: - threadId: ID!

Forces a fresh load of a customer card instance, bypassing the cache. Use this when you know your external data has changed and you want to immediately fetch updated card content from your API URL. The response will be a `CustomerCardInstanceLoading`; subscribe to `customerCardInstanceChanges` to receive the loaded or errored result. Arguments: - input: ReloadCustomerCardInstanceInput!

Set new order values for one or more autoresponders. You must pass a unique `order` integer and a unique autoresponder ID for each entry; duplicate IDs or duplicate order values are rejected. Only the autoresponders included in the input are repositioned — others are left unchanged. Requires the `autoresponder:edit` permission. Arguments: - input: ReorderAutorespondersInput!

Updates the display order of one or more customer card configs. Only the configs listed in the input are updated; other configs keep their current order. This allows you to swap two configs or move a single card without specifying the full list. Duplicate order values are permitted and ties are broken by ID. Arguments: - input: ReorderCustomerCardConfigsInput!

Updates the display order of one or more customer surveys in a single call. Pass an array of survey ID / order-index pairs; only surveys whose order actually changes are updated. Duplicate survey IDs in the input are rejected. Requires the `customerSurvey:edit` permission. Arguments: - input: ReorderCustomerSurveysInput!

Replies to an existing email in a thread, threading the response correctly in email clients. Use inReplyToEmailId to identify the email being replied to. Supports CC and BCC recipients (up to 49 combined) and file attachments. Requires the email:create and email:read permissions. Arguments: - input: ReplyToEmailInput!

Finds or creates a Plain customer associated with the Microsoft Teams users in the given channel, using the workspace's connected MS Teams integration. Useful for bootstrapping a support thread from a Teams channel conversation. Arguments: - input: ResolveCustomerForMSTeamsChannelInput!

Finds or creates a Plain customer associated with a Slack channel, using the Slack users in that channel to identify the customer. Useful for bootstrapping threads from Slack channels. Arguments: - input: ResolveCustomerForSlackChannelInput!

Remove an unsubscribe so a Slack channel can receive broadcasts again. Idempotent: resubscribing a channel that was never unsubscribed is a no-op and returns `unsubscribe: null` with no error. Required input fields: `type`, `slackTeamId`, `slackChannelId`. - `type` must be `SLACK`. A channel id is only unique within its Slack team, so both `slackTeamId` and `slackChannelId` are required together. - When an unsubscribe existed, the response's `unsubscribe` field is the record that was removed (for confirmation). When nothing was opted out, `unsubscribe` is null and `error` is also null. After a successful resubscribe, the channel returns to normal audience resolution: if a filter or named recipient would have included it, it will again. Confirm with `getBroadcastSendTargetRecipients` or `getBroadcastRecipientUnsubscribes` rather than assuming. Prefer confirming the channel identity with the user before calling this.

Returns the roles available in the workspace: the built-in roles (Owner, Admin, Support, Viewer, None) and any custom roles. Requires the `roles:read` permission. Each role's permission list, often hundreds of entries, is left out so every role fits on one page. A custom role's preset and thread scopes come from `customRole`.

Fetches a single saved threads view by its ID. Returns null if no view with the given ID exists in the workspace. Arguments: - savedThreadsViewId: ID!

Returns all saved threads views for the workspace, ordered by creation time. Use this to list the views available in your workspace. Supports forward and backward cursor pagination. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String

Queues a broadcast to be sent, moving it from `DRAFT` to `SCHEDULED`. Calling this again on a broadcast that has not started sending changes when it will go out; once the send has started it is rejected. The broadcast must have a sender and at least one channel. A null `scheduledAt` clears the schedule instead, returning the broadcast to `DRAFT`. Requires the `broadcast:send` and `broadcast:read` permissions. Arguments: - input: ScheduleBroadcastInput!

Searches accounts by name or domain (case-insensitive partial match), or by external ID (exact match). The search term must be at least 2 characters long. Returns a paginated list of results. Requires the `tenant:read` permission. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - searchQuery: AccountsSearchQuery! - filters: AccountsFilter - first: Int - after: String - last: Int - before: String

Search broadcasts by name. The search is case-insensitive, matches on any part of the name, ignores accents, and requires at least 2 characters. A broadcast's `name` is internal only — it is never shown to recipients, so it is safe to search on and to show back to the user. Soft-deleted broadcasts are excluded. Optionally narrow the results with `statuses`, applied on top of the name match. Omit it to search every status — an empty list is rejected. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 50). Broadcast IDs start with `bc_`. Broadcast URL format: https://app.plain.com/workspace/{workspaceId}/broadcasts/{broadcastId} where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`). Do not invent IDs — only use values returned by the MCP tools.

Semantic search across the workspace's knowledge: indexed documents (URLs and sitemaps added as knowledge sources) and help center articles that Plain's AI is allowed to use. This is the same knowledge Ari draws from, but not Ari's exact retrieval, so a result here does not guarantee Ari would have found it. Searches up to `pageSize` matching chunks (default 3, max 50), then returns one result per source, ordered by its most relevant chunk. Each result contains all indexed text from that source, so fewer than `pageSize` results may return and responses grow quickly; only raise `pageSize` if the first results miss. Narrow results with `types` (INDEXED_DOCUMENT, HELP_CENTER_ARTICLE) or `labelTypeIds` (unlabelled content may also be included). When working a knowledge gap, search its title and description before writing new content: no relevant result means the content is missing; a relevant result means it exists but Ari missed it or it is out of date, so improve the existing source rather than creating a duplicate. After updating an indexed document's page, pass its `knowledgeSourceId` to `reindexKnowledgeSource` so Ari picks up the change.

Perform a semantic (vector) search across Plain's own public help center (help.plain.com). Available to every workspace's Sidekick Agent so it can answer questions about how Plain itself works. Read-only and hard-restricted to Plain's public product documentation; it never returns the caller's own data or any other workspace's content. Returns up to `pageSize` results (default 10, max 50) ranked by relevance. Arguments: - searchQuery: String! - pageSize: Int

Searches for slack users in a slack channel based on a search term. The search term can be part of either the slack's handle or full name. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - slackTeamId: String! - slackChannelId: String! - searchQuery: String! - first: Int - after: String - last: Int - before: String

Searches for slack users in a thread based on a search term. The search term can be part of either the slack's handle or full name. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - threadId: ID! - searchQuery: String! - first: Int - after: String - last: Int - before: String

Sends the same email body to multiple threads at once (up to 100 thread IDs per call). Useful for broadcasting updates to a set of customers, for example notifying affected users of an incident. Arguments: - input: SendBulkEmailInput!

Send a chat message from a support agent (or machine user) to a customer on a CHAT-channel thread. Either `text` or at least one `attachmentIds` entry must be provided. If `threadId` is omitted a new thread is created; if supplied the message is appended to the existing thread. An optional `timestamp` (ISO 8601, must be in the past) allows backdating messages when backfilling historical data. Requires the `chat:create` permission and the live-chat billing entitlement. Arguments: - input: SendChatInput!

Sends an outbound Discord message on a thread. Requires both a workspace-level Discord channel integration and a personal user auth integration for the sending user. The message is posted into the Discord thread associated with the Plain thread. Arguments: - input: SendDiscordMessageInput!

Sends a Microsoft Teams message on a thread. The thread must be associated with a connected MS Teams channel and the workspace must have an active MS Teams integration. Arguments: - input: SendMSTeamsMessageInput!

Sends a new outbound email to a customer, creating a new thread by default. Use threadId to attach the email to an existing thread instead. Supports CC and BCC recipients (up to 49 combined), file attachments, and an optional alternate from address. Requires the email:create and email:read permissions. Arguments: - input: SendNewEmailInput!

Sends a Slack message on a thread. The message appears in the thread's associated Slack channel as a reply or new message. Arguments: - input: SendSlackMessageInput!

Send a test copy of a broadcast to Slack channels you name, so you can see what recipients will get before the real audience does. This posts real messages into real channels. Everyone in the channels you name will see it. It carries a notice at the top marking it as a test, and it goes out through the same pipeline and under the broadcast's own sender, so what arrives is what any channel would have received. Confirm the channel list with the user before calling this. - `channels` takes between 1 and 10 `{ slackTeamId, slackChannelId }` pairs. A channel ID is only unique within its Slack team, so both are needed. Every channel must already be connected to this workspace, and naming the same channel twice posts to it once. - The channels are independent of the broadcast's own audience, which is left untouched. The broadcast needs a sender and a notification title, but it does not need any channels of its own — testing is what you do before choosing them. - A test send never changes the broadcast's `status`, and never locks or unlocks editing. Only available while the broadcast can still be edited: once its real send has started, it can no longer be tested. The response includes the test send's id. Pass it to `getBroadcastSendDeliveries` to see whether each channel got it. This does not schedule the real send. Queuing a broadcast to its actual audience is done by a human in the Plain app.

Send a reply to an existing Slack or email discussion. The message is posted in the original channel (as a Slack thread reply or email reply) and recorded in Plain. For Slack discussions you may optionally provide slackBlocks, set unfurlLinks, or broadcast the reply into the parent channel via replyBroadcast (replyBroadcast cannot be combined with attachmentIds). Prefer sendDiscussionMessage for new integrations. Arguments: - input: SendThreadDiscussionMessageInput!

Fetch a single completed service authorization by its ID. Returns null if not found or if the authorization is still pending. Arguments: - serviceAuthorizationId: ID!

List all completed service authorizations for the workspace. Only authorizations with status CONNECTED or REINSTALL_REQUIRED are returned; pending authorizations are excluded. Optionally filter by serviceIntegrationKey. Supports cursor-based pagination. Requires the `serviceAuthorization:read` permission. Not connected yet? Connecting needs the user's approval in the provider. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/integrations` (never the `<workspaceId>` placeholder), then read this again to confirm. Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - first: Int - after: String - last: Int - before: String - filters: ServiceAuthorizationsFilter

Returns the SLA policies in the workspace, sorted by name. Pass `filters` to narrow by name or by the target types a policy holds. Supports cursor-based pagination. Requires the `serviceLevelAgreement:read` permission. Deleting a policy is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/slas/<policy id>` (never the `<workspaceId>` placeholder). Pages of 100 can be too big to read: ask for 50 at a time with `first`, then page on with `after`. Arguments: - filters: ServiceLevelAgreementPoliciesFilter - first: Int - after: String - last: Int - before: String

Returns a single SLA policy by its Plain ID. Returns null if no policy with that ID exists. Requires the `serviceLevelAgreement:read` permission. Deleting a policy is done by the user in the Plain app. Get this workspace's ID and give the user the full link with that ID in it, `https://app.plain.com/workspace/w_…/settings/slas/<policy id>` (never the `<workspaceId>` placeholder). Arguments: - serviceLevelAgreementPolicyId: ID!

Replaces the full set of account memberships for a customer in a single call. Any accounts not included in the input are removed; any new ones are added. Use this when syncing account membership from your own system rather than tracking individual add/remove changes. Requires the `customer:edit`, `customerTenantMembership:create`, and `customerTenantMembership:delete` permissions. Arguments: - input: SetCustomerAccountsInput!

Replaces the full set of tenant memberships for a customer in a single call. Any tenants not included in the input are removed; any new ones are added. Use this when syncing tenant membership from your own system rather than tracking individual add/remove changes. Requires the `customer:edit`, `customerTenantMembership:create`, and `customerTenantMembership:delete` permissions. Deprecated: Use setCustomerAccounts instead Arguments: - input: SetCustomerTenantsInput!

Replaces all auto-join rules for a workspace slack channel integration. The provided rules become the complete set of rules for the integration. Arguments: - input: SetSlackAutoJoinRulesInput!

Maps an account field schema to a built-in Plain concept such as `TIER`, enabling automatic tier assignment based on the field's value. Only one schema can be mapped to a given concept at a time. Arguments: - input: SetupAccountFieldSchemaMappingInput!