Twilio Capabilities

When Datadog detects an API error rate spike above threshold, pages the on-call engineer via PagerDuty and posts a diagnostic summary to the Slack ops channel.

naftiko: "0.5"
info:
  label: "API Error Rate Spike Responder"
  description: "When Datadog detects an API error rate spike above threshold, pages the on-call engineer via PagerDuty and posts a diagnostic summary to the Slack ops channel."
  tags:
    - observability
    - api-reliability
    - datadog
    - pagerduty
    - slack
capability:
  exposes:
    - type: mcp
      namespace: api-reliability
      port: 8080
      tools:
        - name: handle-error-rate-spike
          description: "Given a Datadog alert for API error rate exceeding threshold, trigger a PagerDuty page for the on-call engineer and post diagnostic context to the Slack ops channel."
          inputParameters:
            - name: api_name
              in: body
              type: string
              description: "Name of the Twilio API experiencing the error rate spike (e.g., SMS API, Voice API)."
            - name: error_rate_pct
              in: body
              type: number
              description: "Current error rate percentage triggering the alert."
            - name: threshold_pct
              in: body
              type: number
              description: "Error rate threshold that was exceeded."
            - name: datadog_monitor_url
              in: body
              type: string
              description: "URL to the Datadog monitor showing the spike."
          steps:
            - name: page-oncall
              type: call
              call: "pagerduty-api.create-incident"
              with:
                title: "API Error Spike: {{api_name}} at {{error_rate_pct}}% (threshold: {{threshold_pct}}%)"
                service_id: "$secrets.pagerduty_api_service_id"
                urgency: "high"
            - name: post-ops-alert
              type: call
              call: "slack-api.post-message"
              with:
                channel: "api-reliability"
                text: "Error Rate Spike: {{api_name}} | Rate: {{error_rate_pct}}% (threshold: {{threshold_pct}}%) | PD: {{page-oncall.incident_url}} | Monitor: {{datadog_monitor_url}}"
  consumes:
    - type: http
      namespace: pagerduty-api
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a GitHub Actions pipeline fails on a main branch, creates a Jira bug, annotates Datadog with a deployment marker, and posts an alert to the Slack engineering channel.

naftiko: "0.5"
info:
  label: "CI/CD Pipeline Failure Response"
  description: "When a GitHub Actions pipeline fails on a main branch, creates a Jira bug, annotates Datadog with a deployment marker, and posts an alert to the Slack engineering channel."
  tags:
    - devops
    - cicd
    - github
    - jira
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: devops-cicd
      port: 8080
      tools:
        - name: handle-pipeline-failure
          description: "Given a GitHub Actions pipeline failure event, create a Jira bug ticket, post a Datadog deployment marker, and alert the Slack engineering channel with full context."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name where the pipeline failed."
            - name: workflow_name
              in: body
              type: string
              description: "The GitHub Actions workflow name that failed."
            - name: branch
              in: body
              type: string
              description: "The branch where the failure occurred."
            - name: commit_sha
              in: body
              type: string
              description: "The commit SHA that triggered the failing workflow."
            - name: run_url
              in: body
              type: string
              description: "URL to the failed GitHub Actions run for investigation."
          steps:
            - name: create-jira-bug
              type: call
              call: "jira-cicd.create-issue"
              with:
                project_key: "PLAT"
                issuetype: "Bug"
                summary: "[CI Failure] {{repo_name}} / {{branch}} — {{workflow_name}}"
                description: "Commit: {{commit_sha}}\nBranch: {{branch}}\nWorkflow: {{workflow_name}}\nRun: {{run_url}}"
            - name: annotate-datadog
              type: call
              call: "datadog.create-event"
              with:
                title: "CI Failure: {{repo_name}} - {{workflow_name}}"
                text: "Pipeline failed on {{branch}} at {{commit_sha}}"
                alert_type: "error"
            - name: post-slack-alert
              type: call
              call: "slack-cicd.post-message"
              with:
                channel: "engineering-alerts"
                text: "Pipeline Failure: {{repo_name}} | Branch: {{branch}} | Workflow: {{workflow_name}} | Jira: {{create-jira-bug.key}} | Run: {{run_url}}"
  consumes:
    - type: http
      namespace: jira-cicd
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: slack-cicd
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When AWS Cost Anomaly Detection fires an alert, annotates Datadog, creates a Jira cost investigation ticket, and posts a summary to the FinOps Slack channel.

naftiko: "0.5"
info:
  label: "Cloud Cost Anomaly Responder"
  description: "When AWS Cost Anomaly Detection fires an alert, annotates Datadog, creates a Jira cost investigation ticket, and posts a summary to the FinOps Slack channel."
  tags:
    - finops
    - cloud-cost
    - datadog
    - jira
    - slack
    - aws
capability:
  exposes:
    - type: mcp
      namespace: finops
      port: 8080
      tools:
        - name: handle-cost-anomaly
          description: "Given an AWS cost anomaly event with service name and estimated overage, create a Datadog event annotation, open a Jira investigation ticket, and notify the FinOps Slack channel."
          inputParameters:
            - name: anomaly_id
              in: body
              type: string
              description: "The AWS Cost Anomaly Detection anomaly ID."
            - name: service_name
              in: body
              type: string
              description: "The AWS service exhibiting unexpected cost (e.g., EC2, Lambda, S3)."
            - name: estimated_overage_usd
              in: body
              type: number
              description: "Estimated cost overage in USD."
            - name: team
              in: body
              type: string
              description: "The engineering team responsible for the affected service."
          steps:
            - name: annotate-datadog
              type: call
              call: "datadog-cost.create-event"
              with:
                title: "AWS Cost Anomaly: {{service_name}}"
                text: "Anomaly {{anomaly_id}} — estimated overage: ${{estimated_overage_usd}} — Team: {{team}}"
                alert_type: "warning"
            - name: create-investigation
              type: call
              call: "jira-cost.create-issue"
              with:
                project_key: "FINOPS"
                issuetype: "Task"
                summary: "Cost anomaly investigation: {{service_name}} - ${{estimated_overage_usd}} overage"
                description: "AWS anomaly {{anomaly_id}} on {{service_name}}. Team: {{team}}. Datadog: {{annotate-datadog.url}}"
            - name: notify-finops
              type: call
              call: "slack-cost.post-message"
              with:
                channel: "finops-alerts"
                text: "AWS Cost Anomaly: {{service_name}} | Team: {{team}} | Overage: ${{estimated_overage_usd}} | Jira: {{create-investigation.key}} | Datadog: {{annotate-datadog.url}}"
  consumes:
    - type: http
      namespace: datadog-cost
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: jira-cost
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-cost
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Scans a Confluence space for pages older than 6 months without recent edits, creates Jira tasks for documentation owners, and posts an audit summary to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "Confluence Documentation Quality Audit"
  description: "Scans a Confluence space for pages older than 6 months without recent edits, creates Jira tasks for documentation owners, and posts an audit summary to the engineering Slack channel."
  tags:
    - devops
    - documentation
    - confluence
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: docs-quality
      port: 8080
      tools:
        - name: audit-documentation-quality
          description: "Given a Confluence space key, retrieve pages not updated in over 6 months, create Jira tasks for each owner to review and update, and post an audit summary to Slack."
          inputParameters:
            - name: confluence_space_key
              in: body
              type: string
              description: "The Confluence space key to audit (e.g., PLATFORM, ENG)."
            - name: eng_channel
              in: body
              type: string
              description: "Slack channel to post the documentation audit summary."
          steps:
            - name: get-stale-pages
              type: call
              call: "confluence.search-pages"
              with:
                spaceKey: "{{confluence_space_key}}"
                lastModifiedBefore: "6_months_ago"
            - name: create-review-task
              type: call
              call: "jira-docs.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Task"
                summary: "Documentation review: {{confluence_space_key}} - {{get-stale-pages.count}} stale pages"
                description: "Stale pages identified in {{confluence_space_key}} space. Pages not updated in 6+ months: {{get-stale-pages.count}}"
            - name: post-audit-digest
              type: call
              call: "slack-docs.post-message"
              with:
                channel: "{{eng_channel}}"
                text: "Docs Audit: Space {{confluence_space_key}} | Stale pages (6+ months): {{get-stale-pages.count}} | Review task: {{create-review-task.key}}"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://twilio.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: pages
          path: "/content/search"
          inputParameters:
            - name: spaceKey
              in: query
            - name: lastModifiedBefore
              in: query
          operations:
            - name: search-pages
              method: GET
    - type: http
      namespace: jira-docs
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-docs
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Zendesk ticket is escalated to P1, creates a Salesforce case, triggers a PagerDuty alert, and posts an escalation summary to the Slack customer-support channel.

naftiko: "0.5"
info:
  label: "Customer Support Escalation Handler"
  description: "When a Zendesk ticket is escalated to P1, creates a Salesforce case, triggers a PagerDuty alert, and posts an escalation summary to the Slack customer-support channel."
  tags:
    - customer-support
    - escalation
    - zendesk
    - salesforce
    - pagerduty
    - slack
capability:
  exposes:
    - type: mcp
      namespace: support-escalation
      port: 8080
      tools:
        - name: handle-support-escalation
          description: "Given a Zendesk ticket ID escalated to P1, create a Salesforce support case, trigger a PagerDuty alert, and post the escalation context to the Slack support channel."
          inputParameters:
            - name: zendesk_ticket_id
              in: body
              type: string
              description: "The Zendesk ticket ID being escalated."
            - name: customer_account_name
              in: body
              type: string
              description: "The Salesforce account name of the affected customer."
            - name: issue_summary
              in: body
              type: string
              description: "Brief description of the escalated issue."
          steps:
            - name: get-ticket
              type: call
              call: "zendesk.get-ticket"
              with:
                ticket_id: "{{zendesk_ticket_id}}"
            - name: create-sf-case
              type: call
              call: "salesforce-support.create-case"
              with:
                subject: "P1 Escalation: {{issue_summary}}"
                account_name: "{{customer_account_name}}"
                description: "Zendesk ticket {{zendesk_ticket_id}}: {{get-ticket.description}}"
                priority: "Critical"
            - name: trigger-pagerduty
              type: call
              call: "pagerduty-support.create-incident"
              with:
                title: "P1 Customer Escalation: {{customer_account_name}} - {{issue_summary}}"
                service_id: "$secrets.pagerduty_support_service_id"
                urgency: "high"
            - name: notify-support-channel
              type: call
              call: "slack-support.post-message"
              with:
                channel: "customer-support-escalations"
                text: "P1 ESCALATION: {{customer_account_name}} | {{issue_summary}} | Zendesk: {{zendesk_ticket_id}} | Salesforce: {{create-sf-case.case_number}} | PD: {{trigger-pagerduty.incident_url}}"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://twilio.zendesk.com/api/v2"
      authentication:
        type: basic
        username: "$secrets.zendesk_user"
        password: "$secrets.zendesk_api_token"
      resources:
        - name: tickets
          path: "/tickets/{{ticket_id}}"
          inputParameters:
            - name: ticket_id
              in: path
          operations:
            - name: get-ticket
              method: GET
    - type: http
      namespace: salesforce-support
      baseUri: "https://twilio.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: cases
          path: "/sobjects/Case"
          operations:
            - name: create-case
              method: POST
    - type: http
      namespace: pagerduty-support
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-support
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current status and alert history for a Datadog monitor by ID, for use in incident investigation and SLA reporting.

naftiko: "0.5"
info:
  label: "Datadog Monitor Lookup"
  description: "Retrieves the current status and alert history for a Datadog monitor by ID, for use in incident investigation and SLA reporting."
  tags:
    - observability
    - monitoring
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: get-monitor-status
          description: "Given a Datadog monitor ID, return its current status, last triggered time, and alert count. Use during incident investigation to understand monitor health."
          inputParameters:
            - name: monitor_id
              in: body
              type: string
              description: "The Datadog monitor ID to look up."
          call: "datadog-monitor.get-monitor"
          with:
            monitor_id: "{{monitor_id}}"
          outputParameters:
            - name: name
              type: string
              mapping: "$.name"
            - name: status
              type: string
              mapping: "$.overall_state"
            - name: last_triggered
              type: string
              mapping: "$.state.groups[0].last_triggered_ts"
  consumes:
    - type: http
      namespace: datadog-monitor
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: monitors
          path: "/monitor/{{monitor_id}}"
          inputParameters:
            - name: monitor_id
              in: path
          operations:
            - name: get-monitor
              method: GET

Returns SendGrid service health and delivery pipeline status from Datadog.

naftiko: "0.5"
info:
  label: "Datadog SendGrid Health Check"
  description: "Returns SendGrid service health and delivery pipeline status from Datadog."
  tags:
    - observability
    - datadog
    - email
capability:
  exposes:
    - type: mcp
      namespace: datadog_sendgrid_hea
      port: 8080
      tools:
        - name: query-data
          description: "Returns SendGrid service health and delivery pipeline status from Datadog."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Retrieves SLO compliance data from Datadog for all production services and publishes a weekly SLO digest to the engineering leadership Slack channel.

naftiko: "0.5"
info:
  label: "Datadog SLO Compliance Report"
  description: "Retrieves SLO compliance data from Datadog for all production services and publishes a weekly SLO digest to the engineering leadership Slack channel."
  tags:
    - observability
    - slo
    - reporting
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: slo-reporting
      port: 8080
      tools:
        - name: digest-slo-compliance
          description: "Given a Datadog SLO ID and reporting week, retrieve SLO burn rate and remaining error budget, and post a weekly compliance summary to the engineering leadership Slack channel."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "The Datadog SLO ID to report on."
            - name: reporting_week
              in: body
              type: string
              description: "The ISO week in YYYY-WNN format for the report."
            - name: eng_leadership_channel
              in: body
              type: string
              description: "Slack channel for engineering leadership digest."
          steps:
            - name: get-slo-data
              type: call
              call: "datadog-slo.get-slo"
              with:
                slo_id: "{{slo_id}}"
            - name: post-slo-digest
              type: call
              call: "slack-slo.post-message"
              with:
                channel: "{{eng_leadership_channel}}"
                text: "SLO Report ({{reporting_week}}): {{get-slo-data.name}} | Current: {{get-slo-data.current_slo}}% | Target: {{get-slo-data.target}}% | Error Budget Remaining: {{get-slo-data.error_budget_remaining}}%"
  consumes:
    - type: http
      namespace: datadog-slo
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: slos
          path: "/slo/{{slo_id}}"
          inputParameters:
            - name: slo_id
              in: path
          operations:
            - name: get-slo
              method: GET
    - type: http
      namespace: slack-slo
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns current API latency metrics for Twilio services from Datadog.

naftiko: "0.5"
info:
  label: "Datadog Twilio API Latency Check"
  description: "Returns current API latency metrics for Twilio services from Datadog."
  tags:
    - observability
    - datadog
    - api-health
capability:
  exposes:
    - type: mcp
      namespace: datadog_twilio_api_l
      port: 8080
      tools:
        - name: query-data
          description: "Returns current API latency metrics for Twilio services from Datadog."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Pulls GitHub repository star and fork counts along with Salesforce developer account registrations, and posts a weekly developer community growth digest to the DevRel Slack channel.

naftiko: "0.5"
info:
  label: "Developer Evangelist Content Performance Digest"
  description: "Pulls GitHub repository star and fork counts along with Salesforce developer account registrations, and posts a weekly developer community growth digest to the DevRel Slack channel."
  tags:
    - marketing
    - developer-relations
    - github
    - salesforce
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: devrel-reporting
      port: 8080
      tools:
        - name: digest-devrel-growth
          description: "Given a GitHub repository and Salesforce campaign, retrieve community growth metrics (stars, forks, developer signups) and post a weekly DevRel digest to Slack."
          inputParameters:
            - name: github_repo
              in: body
              type: string
              description: "GitHub repository to track (e.g., twilio/twilio-python)."
            - name: sf_campaign_id
              in: body
              type: string
              description: "Salesforce campaign ID tracking developer signups."
            - name: devrel_channel
              in: body
              type: string
              description: "Slack channel for the DevRel team digest."
          steps:
            - name: get-repo-stats
              type: call
              call: "github-devrel.get-repository"
              with:
                repo: "{{github_repo}}"
            - name: get-signup-stats
              type: call
              call: "salesforce-devrel.get-campaign"
              with:
                campaign_id: "{{sf_campaign_id}}"
            - name: post-devrel-digest
              type: call
              call: "slack-devrel.post-message"
              with:
                channel: "{{devrel_channel}}"
                text: "DevRel Growth: {{github_repo}} | Stars: {{get-repo-stats.stargazers_count}} | Forks: {{get-repo-stats.forks_count}} | Developer signups (campaign): {{get-signup-stats.leads_count}} | Converted: {{get-signup-stats.converted_leads}}"
  consumes:
    - type: http
      namespace: github-devrel
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: repositories
          path: "/repos/{{repo}}"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: get-repository
              method: GET
    - type: http
      namespace: salesforce-devrel
      baseUri: "https://twilio.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: campaigns
          path: "/sobjects/Campaign/{{campaign_id}}"
          inputParameters:
            - name: campaign_id
              in: path
          operations:
            - name: get-campaign
              method: GET
    - type: http
      namespace: slack-devrel
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an employee separates from Twilio, deactivates their Okta account, revokes GitHub access, closes their Zendesk agent profile, and posts a farewell to their Slack team channel.

naftiko: "0.5"
info:
  label: "Employee Offboarding Sequence"
  description: "When an employee separates from Twilio, deactivates their Okta account, revokes GitHub access, closes their Zendesk agent profile, and posts a farewell to their Slack team channel."
  tags:
    - hr
    - offboarding
    - okta
    - github
    - zendesk
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-offboarding
      port: 8080
      tools:
        - name: trigger-employee-offboarding
          description: "Given an employee's email, GitHub username, and Okta user ID, deactivate all accounts across Okta, GitHub, and Zendesk, and post a farewell to their team Slack channel."
          inputParameters:
            - name: okta_user_id
              in: body
              type: string
              description: "The Okta user ID for the departing employee."
            - name: github_username
              in: body
              type: string
              description: "The departing employee's GitHub username."
            - name: zendesk_agent_id
              in: body
              type: string
              description: "The departing employee's Zendesk agent ID (if applicable)."
            - name: team_slack_channel
              in: body
              type: string
              description: "Slack channel for the employee's team for farewell message."
            - name: employee_name
              in: body
              type: string
              description: "Full name of the departing employee."
          steps:
            - name: deactivate-okta
              type: call
              call: "okta-off.deactivate-user"
              with:
                user_id: "{{okta_user_id}}"
            - name: remove-github
              type: call
              call: "github-off.remove-org-member"
              with:
                username: "{{github_username}}"
            - name: deactivate-zendesk
              type: call
              call: "zendesk-off.update-agent"
              with:
                agent_id: "{{zendesk_agent_id}}"
                role: "end-user"
            - name: post-farewell
              type: call
              call: "slack-off.post-message"
              with:
                channel: "{{team_slack_channel}}"
                text: "Today is {{employee_name}}'s last day at Twilio. Please join us in wishing them well on their next chapter!"
  consumes:
    - type: http
      namespace: okta-off
      baseUri: "https://twilio.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users/{{user_id}}/lifecycle/deactivate"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: deactivate-user
              method: POST
    - type: http
      namespace: github-off
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/twilio/members/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: remove-org-member
              method: DELETE
    - type: http
      namespace: zendesk-off
      baseUri: "https://twilio.zendesk.com/api/v2"
      authentication:
        type: basic
        username: "$secrets.zendesk_user"
        password: "$secrets.zendesk_api_token"
      resources:
        - name: agents
          path: "/users/{{agent_id}}"
          inputParameters:
            - name: agent_id
              in: path
          operations:
            - name: update-agent
              method: PUT
    - type: http
      namespace: slack-off
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a pull request is opened in a Twilio GitHub repository, assigns reviewers based on team ownership, creates a Jira sub-task for review tracking, and posts a Slack notification.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Code Review Assignment"
  description: "When a pull request is opened in a Twilio GitHub repository, assigns reviewers based on team ownership, creates a Jira sub-task for review tracking, and posts a Slack notification."
  tags:
    - devops
    - code-review
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: code-review
      port: 8080
      tools:
        - name: assign-pr-reviewers
          description: "Given a GitHub PR number and repository, assign team reviewers, create a Jira sub-task for review tracking, and post a Slack notification to the team channel."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name (e.g., twilio/twilio-python)."
            - name: pr_number
              in: body
              type: integer
              description: "The pull request number."
            - name: jira_parent_key
              in: body
              type: string
              description: "The parent Jira issue key this PR relates to."
            - name: team_slack_channel
              in: body
              type: string
              description: "Slack channel for the owning engineering team."
          steps:
            - name: get-pr
              type: call
              call: "github-pr.get-pull-request"
              with:
                repo: "{{repo_name}}"
                pull_number: "{{pr_number}}"
            - name: create-jira-subtask
              type: call
              call: "jira-pr.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Subtask"
                summary: "Code review: PR #{{pr_number}} - {{get-pr.title}}"
                parent: "{{jira_parent_key}}"
            - name: notify-team
              type: call
              call: "slack-pr.post-message"
              with:
                channel: "{{team_slack_channel}}"
                text: "PR ready for review: {{get-pr.title}} | Repo: {{repo_name}} | PR: {{get-pr.html_url}} | Jira: {{create-jira-subtask.key}}"
  consumes:
    - type: http
      namespace: github-pr
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{repo}}/pulls/{{pull_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: pull_number
              in: path
          operations:
            - name: get-pull-request
              method: GET
    - type: http
      namespace: jira-pr
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-pr
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Triggers a security scan on a GitHub repository, retrieves vulnerability alerts, creates Jira tickets for critical findings, and posts a scan summary to the security Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Repository Security Scan"
  description: "Triggers a security scan on a GitHub repository, retrieves vulnerability alerts, creates Jira tickets for critical findings, and posts a scan summary to the security Slack channel."
  tags:
    - security
    - devops
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: repo-security
      port: 8080
      tools:
        - name: scan-repo-vulnerabilities
          description: "Given a GitHub repository name, retrieve Dependabot vulnerability alerts, create Jira tickets for critical/high severity findings, and post a security scan digest to Slack."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name to scan (e.g., twilio/twilio-python)."
            - name: security_channel
              in: body
              type: string
              description: "Slack channel for the security team digest."
          steps:
            - name: get-vuln-alerts
              type: call
              call: "github-security.get-dependabot-alerts"
              with:
                repo: "{{repo_name}}"
                severity: "critical"
            - name: create-security-ticket
              type: call
              call: "jira-vuln.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "Vulnerability scan: {{repo_name}} - {{get-vuln-alerts.critical_count}} critical findings"
                description: "Repository: {{repo_name}}\nCritical: {{get-vuln-alerts.critical_count}}\nHigh: {{get-vuln-alerts.high_count}}"
            - name: post-scan-digest
              type: call
              call: "slack-vuln.post-message"
              with:
                channel: "{{security_channel}}"
                text: "Security Scan: {{repo_name}} | Critical: {{get-vuln-alerts.critical_count}} | High: {{get-vuln-alerts.high_count}} | Jira: {{create-security-ticket.key}}"
  consumes:
    - type: http
      namespace: github-security
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: dependabot-alerts
          path: "/repos/{{repo}}/dependabot/alerts"
          inputParameters:
            - name: repo
              in: path
            - name: severity
              in: query
          operations:
            - name: get-dependabot-alerts
              method: GET
    - type: http
      namespace: jira-vuln
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-vuln
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Jira for all new unassigned bugs in a project, assigns them to the appropriate team via component ownership, and posts a triage digest to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "Jira Bug Triage and Prioritization"
  description: "Queries Jira for all new unassigned bugs in a project, assigns them to the appropriate team via component ownership, and posts a triage digest to the engineering Slack channel."
  tags:
    - devops
    - bug-triage
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: bug-triage
      port: 8080
      tools:
        - name: triage-new-bugs
          description: "Given a Jira project key, retrieve all new unassigned bugs created in the past 24 hours, post a triage summary to the engineering Slack channel for team assignment."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "The Jira project key to triage (e.g., PLAT, SMS, VOICE)."
            - name: eng_channel
              in: body
              type: string
              description: "Slack channel for the engineering triage digest."
          steps:
            - name: get-new-bugs
              type: call
              call: "jira-triage.search-issues"
              with:
                jql: "project={{project_key}} AND issuetype=Bug AND status=New AND created>=-1d AND assignee is EMPTY"
            - name: post-triage-digest
              type: call
              call: "slack-triage.post-message"
              with:
                channel: "{{eng_channel}}"
                text: "Bug Triage: Project {{project_key}} | New unassigned bugs (24h): {{get-new-bugs.total}} | Critical: {{get-new-bugs.critical_count}} | High: {{get-new-bugs.high_count}} | Please assign ownership in Jira."
  consumes:
    - type: http
      namespace: jira-triage
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/search"
          inputParameters:
            - name: jql
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack-triage
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the status and details of a Twilio platform engineering Jira ticket.

naftiko: "0.5"
info:
  label: "Jira Platform Ticket Status Check"
  description: "Returns the status and details of a Twilio platform engineering Jira ticket."
  tags:
    - devops
    - jira
    - platform
capability:
  exposes:
    - type: mcp
      namespace: jira_platform_ticket
      port: 8080
      tools:
        - name: query-data
          description: "Returns the status and details of a Twilio platform engineering Jira ticket."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Pulls completed story points and velocity data from Jira for a given sprint and posts a velocity digest to the engineering team's Slack channel.

naftiko: "0.5"
info:
  label: "Jira Sprint Velocity Report"
  description: "Pulls completed story points and velocity data from Jira for a given sprint and posts a velocity digest to the engineering team's Slack channel."
  tags:
    - devops
    - reporting
    - jira
    - slack
    - agile
capability:
  exposes:
    - type: mcp
      namespace: agile-reporting
      port: 8080
      tools:
        - name: digest-sprint-velocity
          description: "Given a Jira board ID and sprint ID, retrieve velocity metrics (completed vs committed story points) and post a sprint summary to the team's Slack channel."
          inputParameters:
            - name: board_id
              in: body
              type: string
              description: "The Jira board ID for the engineering team."
            - name: sprint_id
              in: body
              type: string
              description: "The Jira sprint ID to report on."
            - name: team_channel
              in: body
              type: string
              description: "Slack channel where the sprint digest will be posted."
          steps:
            - name: get-sprint-data
              type: call
              call: "jira-velocity.get-sprint"
              with:
                boardId: "{{board_id}}"
                sprintId: "{{sprint_id}}"
            - name: post-digest
              type: call
              call: "slack-velocity.post-message"
              with:
                channel: "{{team_channel}}"
                text: "Sprint Velocity Report: Sprint {{get-sprint-data.name}} | Committed: {{get-sprint-data.committed_points}} pts | Completed: {{get-sprint-data.completed_points}} pts | Velocity: {{get-sprint-data.velocity_pct}}%"
  consumes:
    - type: http
      namespace: jira-velocity
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: sprints
          path: "/board/{{boardId}}/sprint/{{sprintId}}"
          inputParameters:
            - name: boardId
              in: path
            - name: sprintId
              in: path
          operations:
            - name: get-sprint
              method: GET
    - type: http
      namespace: slack-velocity
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls Salesforce campaign performance metrics and posts a weekly campaign digest to the marketing leadership Slack channel.

naftiko: "0.5"
info:
  label: "Marketing Campaign Performance Digest"
  description: "Pulls Salesforce campaign performance metrics and posts a weekly campaign digest to the marketing leadership Slack channel."
  tags:
    - marketing
    - salesforce
    - slack
    - reporting
    - campaign
capability:
  exposes:
    - type: mcp
      namespace: marketing-reporting
      port: 8080
      tools:
        - name: digest-campaign-performance
          description: "Given a Salesforce campaign ID and reporting period, retrieve campaign performance metrics (leads, conversions, spend) and post a digest to the marketing leadership Slack channel."
          inputParameters:
            - name: campaign_id
              in: body
              type: string
              description: "The Salesforce campaign ID to report on."
            - name: marketing_channel
              in: body
              type: string
              description: "Slack channel for the marketing leadership digest."
          steps:
            - name: get-campaign-stats
              type: call
              call: "salesforce-mktg.get-campaign"
              with:
                campaign_id: "{{campaign_id}}"
            - name: post-campaign-digest
              type: call
              call: "slack-mktg.post-message"
              with:
                channel: "{{marketing_channel}}"
                text: "Campaign Performance: {{get-campaign-stats.name}} | Leads: {{get-campaign-stats.leads_count}} | Converted: {{get-campaign-stats.converted_leads}} | Opportunities: {{get-campaign-stats.opportunities_count}} | Pipeline: ${{get-campaign-stats.expected_revenue}}"
  consumes:
    - type: http
      namespace: salesforce-mktg
      baseUri: "https://twilio.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: campaigns
          path: "/sobjects/Campaign/{{campaign_id}}"
          inputParameters:
            - name: campaign_id
              in: path
          operations:
            - name: get-campaign
              method: GET
    - type: http
      namespace: slack-mktg
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new software engineer is created in Workday, opens a Jira onboarding epic, provisions GitHub access, and sends a Slack welcome message to the engineering team channel.

naftiko: "0.5"
info:
  label: "New Engineer Onboarding Orchestrator"
  description: "When a new software engineer is created in Workday, opens a Jira onboarding epic, provisions GitHub access, and sends a Slack welcome message to the engineering team channel."
  tags:
    - hr
    - onboarding
    - workday
    - jira
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-onboarding
      port: 8080
      tools:
        - name: trigger-engineer-onboarding
          description: "Given a Workday employee ID and team assignment, orchestrate full engineering onboarding: create a Jira epic, provision GitHub org access, and post a Slack welcome."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID for the new engineer."
            - name: team_name
              in: body
              type: string
              description: "The engineering team the new hire is joining (e.g., platform, messaging, growth)."
            - name: github_username
              in: body
              type: string
              description: "The new hire's GitHub username for org provisioning."
            - name: start_date
              in: body
              type: string
              description: "Start date in YYYY-MM-DD format."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: create-jira-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Epic"
                summary: "Onboarding: {{get-employee.full_name}} - {{team_name}} - {{start_date}}"
                description: "Engineering onboarding epic for {{get-employee.first_name}} joining the {{team_name}} team."
            - name: invite-github
              type: call
              call: "github.add-org-member"
              with:
                username: "{{github_username}}"
                role: "member"
            - name: post-welcome
              type: call
              call: "slack.post-message"
              with:
                channel: "engineering"
                text: "Welcome {{get-employee.first_name}} {{get-employee.last_name}} to the {{team_name}} team! They start {{start_date}}. Say hello and help them get set up. Onboarding epic: {{create-jira-epic.key}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/twilio/memberships/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: add-org-member
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new employee is created in Workday, provisions their Okta account with group memberships based on their role and sends a Slack notification with setup instructions.

naftiko: "0.5"
info:
  label: "Okta User Provisioning on Hire"
  description: "When a new employee is created in Workday, provisions their Okta account with group memberships based on their role and sends a Slack notification with setup instructions."
  tags:
    - identity
    - security
    - okta
    - workday
    - slack
capability:
  exposes:
    - type: mcp
      namespace: identity-provisioning
      port: 8080
      tools:
        - name: provision-okta-user
          description: "Given a Workday employee ID and role, create an Okta user account, assign role-appropriate groups, and post onboarding instructions to the new hire in Slack."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID for the new hire."
            - name: employee_email
              in: body
              type: string
              description: "The new hire's corporate email address."
            - name: role
              in: body
              type: string
              description: "The employee's role for group assignment (e.g., engineering, sales, support)."
          steps:
            - name: get-employee
              type: call
              call: "workday-okta.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: create-okta-user
              type: call
              call: "okta.create-user"
              with:
                email: "{{employee_email}}"
                firstName: "{{get-employee.first_name}}"
                lastName: "{{get-employee.last_name}}"
                login: "{{employee_email}}"
            - name: notify-new-hire
              type: call
              call: "slack-okta.post-message"
              with:
                channel: "{{employee_email}}"
                text: "Welcome to Twilio! Your Okta account has been provisioned. Log in at https://twilio.okta.com with {{employee_email}}. You'll receive a setup email shortly."
  consumes:
    - type: http
      namespace: workday-okta
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: okta
      baseUri: "https://twilio.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: slack-okta
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog monitor fires a P1 alert, creates a PagerDuty incident, opens a Jira issue for tracking, and posts an incident bridge link to the Slack ops channel.

naftiko: "0.5"
info:
  label: "Production Incident Response"
  description: "When a Datadog monitor fires a P1 alert, creates a PagerDuty incident, opens a Jira issue for tracking, and posts an incident bridge link to the Slack ops channel."
  tags:
    - operations
    - incident-response
    - datadog
    - pagerduty
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: incident-response
      port: 8080
      tools:
        - name: handle-production-incident
          description: "Given a Datadog monitor alert, trigger a PagerDuty incident, create a Jira issue for post-mortem tracking, and post an incident war room link to Slack ops."
          inputParameters:
            - name: monitor_name
              in: body
              type: string
              description: "The name of the Datadog monitor that fired."
            - name: service_name
              in: body
              type: string
              description: "The affected Twilio service or product (e.g., SMS API, Voice API, Flex)."
            - name: severity
              in: body
              type: string
              description: "Incident severity: P1, P2, P3."
            - name: monitor_url
              in: body
              type: string
              description: "URL to the Datadog monitor for investigation."
          steps:
            - name: trigger-pagerduty
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "{{severity}}: {{service_name}} - {{monitor_name}}"
                service_id: "$secrets.pagerduty_service_id"
                urgency: "high"
            - name: create-jira-incident
              type: call
              call: "jira-incident.create-issue"
              with:
                project_key: "OPS"
                issuetype: "Incident"
                summary: "{{severity}} Incident: {{service_name}} - {{monitor_name}}"
                description: "Monitor: {{monitor_name}}\nService: {{service_name}}\nDatadog: {{monitor_url}}\nPagerDuty: {{trigger-pagerduty.incident_url}}"
            - name: post-ops-alert
              type: call
              call: "slack-ops.post-message"
              with:
                channel: "incidents"
                text: "{{severity}} INCIDENT: {{service_name}} | {{monitor_name}} | Jira: {{create-jira-incident.key}} | PD: {{trigger-pagerduty.incident_url}} | Monitor: {{monitor_url}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira-incident
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-ops
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls open requisition and candidate pipeline data from Workday Recruiting for a given department and posts a weekly hiring digest to the HR leadership Slack channel.

naftiko: "0.5"
info:
  label: "Recruiting Pipeline Status Report"
  description: "Pulls open requisition and candidate pipeline data from Workday Recruiting for a given department and posts a weekly hiring digest to the HR leadership Slack channel."
  tags:
    - hr
    - recruiting
    - workday
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: recruiting-reporting
      port: 8080
      tools:
        - name: digest-recruiting-pipeline
          description: "Given a department name and reporting week, retrieve open requisitions and candidate pipeline stages from Workday and post a hiring digest to the HR leadership Slack channel."
          inputParameters:
            - name: department
              in: body
              type: string
              description: "The department to report on (e.g., Engineering, Sales, Support)."
            - name: hr_leadership_channel
              in: body
              type: string
              description: "Slack channel for HR leadership digest."
          steps:
            - name: get-requisitions
              type: call
              call: "workday-recruiting.get-job-requisitions"
              with:
                department: "{{department}}"
                status: "open"
            - name: post-recruiting-digest
              type: call
              call: "slack-recruiting.post-message"
              with:
                channel: "{{hr_leadership_channel}}"
                text: "Recruiting Pipeline - {{department}}: Open requisitions: {{get-requisitions.open_count}} | Candidates in pipeline: {{get-requisitions.candidate_count}} | Offers pending: {{get-requisitions.offers_pending}} | Time-to-fill avg: {{get-requisitions.avg_days_open}} days"
  consumes:
    - type: http
      namespace: workday-recruiting
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: job-requisitions
          path: "/jobRequisitions"
          inputParameters:
            - name: department
              in: query
            - name: status
              in: query
          operations:
            - name: get-job-requisitions
              method: GET
    - type: http
      namespace: slack-recruiting
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Calculates and updates account health scores in Salesforce based on recent support ticket volume from Zendesk and product usage signals, and alerts CSMs of at-risk accounts via Slack.

naftiko: "0.5"
info:
  label: "Salesforce Account Health Score Update"
  description: "Calculates and updates account health scores in Salesforce based on recent support ticket volume from Zendesk and product usage signals, and alerts CSMs of at-risk accounts via Slack."
  tags:
    - customer-success
    - salesforce
    - zendesk
    - slack
capability:
  exposes:
    - type: mcp
      namespace: account-health
      port: 8080
      tools:
        - name: update-account-health-score
          description: "Given a Salesforce account ID, retrieve recent Zendesk ticket volume for the account, calculate a health score, update Salesforce, and notify the CSM via Slack if the account is at risk."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "The Salesforce account ID to evaluate."
            - name: csm_slack_id
              in: body
              type: string
              description: "Slack user ID of the Customer Success Manager for the account."
          steps:
            - name: get-account
              type: call
              call: "salesforce-health.get-account"
              with:
                account_id: "{{account_id}}"
            - name: get-zendesk-tickets
              type: call
              call: "zendesk-health.get-tickets"
              with:
                organization_name: "{{get-account.name}}"
                created_after: "30_days_ago"
            - name: update-health-score
              type: call
              call: "salesforce-health.update-account"
              with:
                account_id: "{{account_id}}"
                health_score: "{{get-zendesk-tickets.health_score}}"
            - name: alert-csm
              type: call
              call: "slack-health.post-message"
              with:
                channel: "{{csm_slack_id}}"
                text: "Account health update: {{get-account.name}} | Score: {{get-zendesk-tickets.health_score}} | Tickets (30d): {{get-zendesk-tickets.ticket_count}} | Status: {{update-health-score.health_status}}"
  consumes:
    - type: http
      namespace: salesforce-health
      baseUri: "https://twilio.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: get-account
              method: GET
            - name: update-account
              method: PATCH
    - type: http
      namespace: zendesk-health
      baseUri: "https://twilio.zendesk.com/api/v2"
      authentication:
        type: basic
        username: "$secrets.zendesk_user"
        password: "$secrets.zendesk_api_token"
      resources:
        - name: tickets
          path: "/tickets"
          inputParameters:
            - name: organization_name
              in: query
            - name: created_after
              in: query
          operations:
            - name: get-tickets
              method: GET
    - type: http
      namespace: slack-health
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns Twilio customer account details from Salesforce including plan and ARR.

naftiko: "0.5"
info:
  label: "Salesforce Customer Account Lookup"
  description: "Returns Twilio customer account details from Salesforce including plan and ARR."
  tags:
    - crm
    - salesforce
    - accounts
capability:
  exposes:
    - type: mcp
      namespace: salesforce_customer_
      port: 8080
      tools:
        - name: query-data
          description: "Returns Twilio customer account details from Salesforce including plan and ARR."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When a developer shows high engagement with Twilio's GitHub repos, enriches their Salesforce lead record with developer signals and notifies the owning sales rep in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Lead Enrichment from GitHub Activity"
  description: "When a developer shows high engagement with Twilio's GitHub repos, enriches their Salesforce lead record with developer signals and notifies the owning sales rep in Slack."
  tags:
    - sales
    - crm
    - salesforce
    - github
    - slack
    - developer-relations
capability:
  exposes:
    - type: mcp
      namespace: dev-sales
      port: 8080
      tools:
        - name: enrich-developer-lead
          description: "Given a GitHub username and Salesforce lead ID, pull the developer's GitHub profile stats and update the Salesforce lead with developer engagement signals, then notify the sales rep in Slack."
          inputParameters:
            - name: github_username
              in: body
              type: string
              description: "The developer's GitHub username."
            - name: salesforce_lead_id
              in: body
              type: string
              description: "The Salesforce lead ID to update."
            - name: sales_rep_slack_id
              in: body
              type: string
              description: "Slack user ID of the owning sales representative."
          steps:
            - name: get-github-profile
              type: call
              call: "github-sales.get-user"
              with:
                username: "{{github_username}}"
            - name: update-sf-lead
              type: call
              call: "salesforce.update-lead"
              with:
                lead_id: "{{salesforce_lead_id}}"
                github_profile: "https://github.com/{{github_username}}"
                github_followers: "{{get-github-profile.followers}}"
                github_public_repos: "{{get-github-profile.public_repos}}"
            - name: notify-sales-rep
              type: call
              call: "slack-sales.post-message"
              with:
                channel: "{{sales_rep_slack_id}}"
                text: "Developer signal: {{get-github-profile.name}} (@{{github_username}}) has {{get-github-profile.followers}} followers and {{get-github-profile.public_repos}} repos. Salesforce lead updated: {{update-sf-lead.url}}"
  consumes:
    - type: http
      namespace: github-sales
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: users
          path: "/users/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: get-user
              method: GET
    - type: http
      namespace: salesforce
      baseUri: "https://twilio.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: leads
          path: "/sobjects/Lead/{{lead_id}}"
          inputParameters:
            - name: lead_id
              in: path
          operations:
            - name: update-lead
              method: PATCH
    - type: http
      namespace: slack-sales
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Salesforce opportunity moves to the Closed Won stage, updates the account record, creates a Jira customer success onboarding epic, and notifies the CS team in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Opportunity Stage Update"
  description: "When a Salesforce opportunity moves to the Closed Won stage, updates the account record, creates a Jira customer success onboarding epic, and notifies the CS team in Slack."
  tags:
    - sales
    - crm
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: sales-ops
      port: 8080
      tools:
        - name: handle-opportunity-closed-won
          description: "Given a Salesforce opportunity ID marked Closed Won, update the account, create a Jira CS onboarding epic, and notify the customer success team in Slack."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID that was closed won."
            - name: account_id
              in: body
              type: string
              description: "The Salesforce account ID of the winning customer."
          steps:
            - name: get-opportunity
              type: call
              call: "salesforce-oppty.get-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: update-account
              type: call
              call: "salesforce-oppty.update-account"
              with:
                account_id: "{{account_id}}"
                customer_since: "today"
            - name: create-cs-epic
              type: call
              call: "jira-cs.create-issue"
              with:
                project_key: "CS"
                issuetype: "Epic"
                summary: "Customer Onboarding: {{get-opportunity.account_name}} - {{get-opportunity.name}}"
                description: "Closed Won opportunity: {{opportunity_id}}. ARR: {{get-opportunity.amount}}. Owner: {{get-opportunity.owner_name}}"
            - name: notify-cs-team
              type: call
              call: "slack-cs.post-message"
              with:
                channel: "customer-success"
                text: "New customer: {{get-opportunity.account_name}} | ARR: ${{get-opportunity.amount}} | Deal: {{get-opportunity.name}} | Onboarding epic: {{create-cs-epic.key}}"
  consumes:
    - type: http
      namespace: salesforce-oppty
      baseUri: "https://twilio.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: update-account
              method: PATCH
    - type: http
      namespace: jira-cs
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-cs
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a CrowdStrike detection fires, creates a Jira security ticket, posts a Slack alert to the security channel, and triggers a Datadog event for correlation.

naftiko: "0.5"
info:
  label: "Security Vulnerability Triage"
  description: "When a CrowdStrike detection fires, creates a Jira security ticket, posts a Slack alert to the security channel, and triggers a Datadog event for correlation."
  tags:
    - security
    - vulnerability-management
    - crowdstrike
    - jira
    - slack
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: triage-security-detection
          description: "Given a CrowdStrike detection ID and severity, create a Jira security ticket, alert the security Slack channel, and post a Datadog event for SOC correlation."
          inputParameters:
            - name: detection_id
              in: body
              type: string
              description: "The CrowdStrike detection ID."
            - name: hostname
              in: body
              type: string
              description: "The hostname of the affected system."
            - name: severity
              in: body
              type: string
              description: "Detection severity: critical, high, medium, low."
            - name: tactic
              in: body
              type: string
              description: "MITRE ATT&CK tactic associated with the detection."
          steps:
            - name: create-security-ticket
              type: call
              call: "jira-security.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "[{{severity}}] CrowdStrike Detection: {{tactic}} on {{hostname}}"
                description: "Detection ID: {{detection_id}}\nHost: {{hostname}}\nSeverity: {{severity}}\nTactic: {{tactic}}"
            - name: alert-security-channel
              type: call
              call: "slack-security.post-message"
              with:
                channel: "security-alerts"
                text: "Security Detection: {{severity}} | Host: {{hostname}} | Tactic: {{tactic}} | Jira: {{create-security-ticket.key}} | Detection: {{detection_id}}"
            - name: post-datadog-event
              type: call
              call: "datadog-security.create-event"
              with:
                title: "CrowdStrike Detection: {{hostname}}"
                text: "{{tactic}} detection ({{severity}}) on {{hostname}}. Detection ID: {{detection_id}}"
                alert_type: "error"
  consumes:
    - type: http
      namespace: jira-security
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-security
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: datadog-security
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST

Queries Snowflake for customer engagement metrics across messaging channels.

naftiko: "0.5"
info:
  label: "Snowflake Customer Engagement Query"
  description: "Queries Snowflake for customer engagement metrics across messaging channels."
  tags:
    - analytics
    - snowflake
    - engagement
capability:
  exposes:
    - type: mcp
      namespace: snowflake_customer_e
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for customer engagement metrics across messaging channels."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries Snowflake for pipeline run status and row count anomalies, then posts a data quality digest to the data engineering Slack channel and creates a Jira ticket for failures.

naftiko: "0.5"
info:
  label: "Snowflake Data Pipeline Health Check"
  description: "Queries Snowflake for pipeline run status and row count anomalies, then posts a data quality digest to the data engineering Slack channel and creates a Jira ticket for failures."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: check-pipeline-health
          description: "Given a Snowflake database and pipeline name, query execution history for failures or anomalies, post a health digest to Slack, and open a Jira ticket for any detected failures."
          inputParameters:
            - name: database_name
              in: body
              type: string
              description: "The Snowflake database containing the pipeline tables."
            - name: pipeline_name
              in: body
              type: string
              description: "The name of the data pipeline to check."
            - name: data_channel
              in: body
              type: string
              description: "Slack channel for the data engineering team."
          steps:
            - name: get-pipeline-status
              type: call
              call: "snowflake.query-pipeline-status"
              with:
                database: "{{database_name}}"
                pipeline: "{{pipeline_name}}"
            - name: create-failure-ticket
              type: call
              call: "jira-data.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Pipeline failure: {{pipeline_name}} in {{database_name}}"
                description: "Pipeline {{pipeline_name}} failed. Last run: {{get-pipeline-status.last_run}}. Rows processed: {{get-pipeline-status.row_count}}"
            - name: post-health-digest
              type: call
              call: "slack-data.post-message"
              with:
                channel: "{{data_channel}}"
                text: "Pipeline Health: {{pipeline_name}} | Status: {{get-pipeline-status.status}} | Last Run: {{get-pipeline-status.last_run}} | Rows: {{get-pipeline-status.row_count}} | Jira: {{create-failure-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: queries
          path: "/statements"
          operations:
            - name: query-pipeline-status
              method: POST
    - type: http
      namespace: jira-data
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-data
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for developer adoption metrics including new accounts and API keys.

naftiko: "0.5"
info:
  label: "Snowflake Developer Adoption Query"
  description: "Queries Snowflake for developer adoption metrics including new accounts and API keys."
  tags:
    - analytics
    - snowflake
    - developer-experience
capability:
  exposes:
    - type: mcp
      namespace: snowflake_developer_
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for developer adoption metrics including new accounts and API keys."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Queries Snowflake for messaging volume trends by channel and time period.

naftiko: "0.5"
info:
  label: "Snowflake Messaging Analytics Query"
  description: "Queries Snowflake for messaging volume trends by channel and time period."
  tags:
    - analytics
    - snowflake
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: snowflake_messaging_
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for messaging volume trends by channel and time period."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Retrieves top long-running queries from Snowflake's query history, creates Jira optimization tasks for the data engineering team, and posts a performance summary to Slack.

naftiko: "0.5"
info:
  label: "Snowflake Query Performance Audit"
  description: "Retrieves top long-running queries from Snowflake's query history, creates Jira optimization tasks for the data engineering team, and posts a performance summary to Slack."
  tags:
    - data
    - snowflake
    - jira
    - slack
    - performance
capability:
  exposes:
    - type: mcp
      namespace: data-performance
      port: 8080
      tools:
        - name: audit-query-performance
          description: "Given a Snowflake warehouse and time window, retrieve top-10 longest-running queries, create a Jira optimization task for the data team, and post a performance digest to Slack."
          inputParameters:
            - name: warehouse_name
              in: body
              type: string
              description: "The Snowflake warehouse to audit query performance for."
            - name: hours_back
              in: body
              type: integer
              description: "Number of hours back to look in query history (e.g., 24)."
            - name: data_channel
              in: body
              type: string
              description: "Slack channel for the data engineering team."
          steps:
            - name: get-slow-queries
              type: call
              call: "snowflake-perf.query-history"
              with:
                warehouse: "{{warehouse_name}}"
                hours: "{{hours_back}}"
            - name: create-optimization-task
              type: call
              call: "jira-perf.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Task"
                summary: "Query optimization: {{warehouse_name}} - {{get-slow-queries.slow_query_count}} slow queries"
                description: "Top slow query: {{get-slow-queries.top_query_id}} running {{get-slow-queries.max_duration_seconds}}s"
            - name: post-perf-digest
              type: call
              call: "slack-perf.post-message"
              with:
                channel: "{{data_channel}}"
                text: "Query Performance: {{warehouse_name}} (last {{hours_back}}h) | Slow queries: {{get-slow-queries.slow_query_count}} | Max duration: {{get-slow-queries.max_duration_seconds}}s | Optimization task: {{create-optimization-task.key}}"
  consumes:
    - type: http
      namespace: snowflake-perf
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: query-history
          path: "/statements"
          inputParameters:
            - name: warehouse
              in: query
            - name: hours
              in: query
          operations:
            - name: query-history
              method: POST
    - type: http
      namespace: jira-perf
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-perf
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Terraform Cloud plan is created for a production workspace, creates a Jira approval task, notifies the infrastructure team in Slack, and posts a Datadog event.

naftiko: "0.5"
info:
  label: "Terraform Infrastructure Provisioning Approval"
  description: "When a Terraform Cloud plan is created for a production workspace, creates a Jira approval task, notifies the infrastructure team in Slack, and posts a Datadog event."
  tags:
    - cloud
    - infrastructure
    - terraform
    - jira
    - slack
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: infra-provisioning
      port: 8080
      tools:
        - name: request-terraform-approval
          description: "Given a Terraform Cloud workspace and plan ID, create a Jira approval task for the infrastructure change, notify the infra team in Slack, and post a Datadog event for auditability."
          inputParameters:
            - name: workspace_name
              in: body
              type: string
              description: "The Terraform Cloud workspace name (e.g., production-us-east-1)."
            - name: plan_id
              in: body
              type: string
              description: "The Terraform Cloud plan ID pending approval."
            - name: resource_count
              in: body
              type: integer
              description: "Number of resources to be added, changed, or destroyed."
            - name: infra_channel
              in: body
              type: string
              description: "Slack channel for the infrastructure team."
          steps:
            - name: get-plan
              type: call
              call: "terraform.get-plan"
              with:
                plan_id: "{{plan_id}}"
            - name: create-approval-task
              type: call
              call: "jira-terraform.create-issue"
              with:
                project_key: "INFRA"
                issuetype: "Task"
                summary: "Terraform approval: {{workspace_name}} - {{resource_count}} resource changes"
                description: "Plan ID: {{plan_id}}\nWorkspace: {{workspace_name}}\nChanges: {{resource_count}} resources"
            - name: notify-infra-team
              type: call
              call: "slack-terraform.post-message"
              with:
                channel: "{{infra_channel}}"
                text: "Terraform plan pending approval: {{workspace_name}} | {{resource_count}} resource changes | Jira: {{create-approval-task.key}} | Plan: {{plan_id}}"
            - name: log-datadog-event
              type: call
              call: "datadog-terraform.create-event"
              with:
                title: "Terraform Plan: {{workspace_name}}"
                text: "Plan {{plan_id}} pending approval. {{resource_count}} resource changes."
                alert_type: "info"
  consumes:
    - type: http
      namespace: terraform
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: plans
          path: "/plans/{{plan_id}}"
          inputParameters:
            - name: plan_id
              in: path
          operations:
            - name: get-plan
              method: GET
    - type: http
      namespace: jira-terraform
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-terraform
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: datadog-terraform
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: events
          path: "/events"
          operations:
            - name: create-event
              method: POST

Tracks A2P 10DLC campaign registrations from Snowflake, creates Jira tasks for rejections, and notifies the messaging team.

naftiko: "0.5"
info:
  label: "Twilio A2P 10DLC Registration Tracker"
  description: "Tracks A2P 10DLC campaign registrations from Snowflake, creates Jira tasks for rejections, and notifies the messaging team."
  tags:
    - compliance
    - snowflake
    - jira
    - slack
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: twilio_a2p_10dlc_reg
      port: 8080
      tools:
        - name: handle-event
          description: "Tracks A2P 10DLC campaign registrations from Snowflake, creates Jira tasks for rejections, and notifies the messaging team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[compliance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "compliance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a trust violation is detected, suspends the account, creates a ServiceNow case, and notifies the compliance team.

naftiko: "0.5"
info:
  label: "Twilio Account Suspension Workflow"
  description: "When a trust violation is detected, suspends the account, creates a ServiceNow case, and notifies the compliance team."
  tags:
    - security
    - servicenow
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: twilio_account_suspe
      port: 8080
      tools:
        - name: handle-event
          description: "When a trust violation is detected, suspends the account, creates a ServiceNow case, and notifies the compliance team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[security] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "security-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns current month usage and billing data for a Twilio account.

naftiko: "0.5"
info:
  label: "Twilio Account Usage Lookup"
  description: "Returns current month usage and billing data for a Twilio account."
  tags:
    - communications
    - twilio
    - billing
capability:
  exposes:
    - type: mcp
      namespace: twilio_account_usage
      port: 8080
      tools:
        - name: query-data
          description: "Returns current month usage and billing data for a Twilio account."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Analyzes API error patterns from Snowflake, creates Jira engineering tickets for systematic issues, and posts findings to Slack.

naftiko: "0.5"
info:
  label: "Twilio API Error Pattern Analyzer"
  description: "Analyzes API error patterns from Snowflake, creates Jira engineering tickets for systematic issues, and posts findings to Slack."
  tags:
    - devops
    - snowflake
    - jira
    - slack
    - api-reliability
capability:
  exposes:
    - type: mcp
      namespace: twilio_api_error_pat
      port: 8080
      tools:
        - name: handle-event
          description: "Analyzes API error patterns from Snowflake, creates Jira engineering tickets for systematic issues, and posts findings to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[devops] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "devops-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When API keys approach expiration, notifies the customer via SendGrid, creates a Jira tracking task, and alerts the security team.

naftiko: "0.5"
info:
  label: "Twilio API Key Rotation Workflow"
  description: "When API keys approach expiration, notifies the customer via SendGrid, creates a Jira tracking task, and alerts the security team."
  tags:
    - security
    - jira
    - slack
    - api-management
capability:
  exposes:
    - type: mcp
      namespace: twilio_api_key_rotat
      port: 8080
      tools:
        - name: handle-event
          description: "When API keys approach expiration, notifies the customer via SendGrid, creates a Jira tracking task, and alerts the security team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[security] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "security-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns intent classification accuracy metrics for Twilio Autopilot bots.

naftiko: "0.5"
info:
  label: "Twilio Autopilot Intent Accuracy"
  description: "Returns intent classification accuracy metrics for Twilio Autopilot bots."
  tags:
    - communications
    - twilio
    - ai
capability:
  exposes:
    - type: mcp
      namespace: twilio_autopilot_int
      port: 8080
      tools:
        - name: query-data
          description: "Returns intent classification accuracy metrics for Twilio Autopilot bots."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When new training data is available, triggers model retraining, creates a Jira deployment task, and notifies the AI team.

naftiko: "0.5"
info:
  label: "Twilio Autopilot Training Pipeline"
  description: "When new training data is available, triggers model retraining, creates a Jira deployment task, and notifies the AI team."
  tags:
    - communications
    - jira
    - slack
    - ai
    - ml
capability:
  exposes:
    - type: mcp
      namespace: twilio_autopilot_tra
      port: 8080
      tools:
        - name: handle-event
          description: "When new training data is available, triggers model retraining, creates a Jira deployment task, and notifies the AI team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a customer enrolls in Branded Calling, provisions the service, updates Salesforce, and notifies the product team.

naftiko: "0.5"
info:
  label: "Twilio Branded Calling Enrollment Workflow"
  description: "When a customer enrolls in Branded Calling, provisions the service, updates Salesforce, and notifies the product team."
  tags:
    - communications
    - salesforce
    - jira
    - slack
    - voice
capability:
  exposes:
    - type: mcp
      namespace: twilio_branded_calli
      port: 8080
      tools:
        - name: handle-event
          description: "When a customer enrolls in Branded Calling, provisions the service, updates Salesforce, and notifies the product team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates capacity forecasts from Snowflake, creates Jira planning epics, and posts projections to Slack.

naftiko: "0.5"
info:
  label: "Twilio Capacity Planning Forecast"
  description: "Generates capacity forecasts from Snowflake, creates Jira planning epics, and posts projections to Slack."
  tags:
    - infrastructure
    - snowflake
    - jira
    - slack
    - capacity
capability:
  exposes:
    - type: mcp
      namespace: twilio_capacity_plan
      port: 8080
      tools:
        - name: handle-event
          description: "Generates capacity forecasts from Snowflake, creates Jira planning epics, and posts projections to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[infrastructure] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "infrastructure-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates daily carrier network health reports from Snowflake, creates Jira tickets for degraded carriers, and posts to Slack.

naftiko: "0.5"
info:
  label: "Twilio Carrier Network Health Digest"
  description: "Generates daily carrier network health reports from Snowflake, creates Jira tickets for degraded carriers, and posts to Slack."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - carriers
capability:
  exposes:
    - type: mcp
      namespace: twilio_carrier_netwo
      port: 8080
      tools:
        - name: handle-event
          description: "Generates daily carrier network health reports from Snowflake, creates Jira tickets for degraded carriers, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a compliance hold is approved for release, updates account status, creates a ServiceNow audit record, and notifies compliance.

naftiko: "0.5"
info:
  label: "Twilio Compliance Hold Release Workflow"
  description: "When a compliance hold is approved for release, updates account status, creates a ServiceNow audit record, and notifies compliance."
  tags:
    - compliance
    - servicenow
    - slack
    - trust-safety
capability:
  exposes:
    - type: mcp
      namespace: twilio_compliance_ho
      port: 8080
      tools:
        - name: handle-event
          description: "When a compliance hold is approved for release, updates account status, creates a ServiceNow audit record, and notifies compliance."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[compliance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "compliance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a messaging content template is submitted, validates compliance, creates a Jira review task, and notifies the trust team.

naftiko: "0.5"
info:
  label: "Twilio Content Template Approval Workflow"
  description: "When a messaging content template is submitted, validates compliance, creates a Jira review task, and notifies the trust team."
  tags:
    - compliance
    - jira
    - slack
    - messaging
    - content
capability:
  exposes:
    - type: mcp
      namespace: twilio_content_templ
      port: 8080
      tools:
        - name: handle-event
          description: "When a messaging content template is submitted, validates compliance, creates a Jira review task, and notifies the trust team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[compliance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "compliance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for Conversations API usage metrics by customer.

naftiko: "0.5"
info:
  label: "Twilio Conversations Metrics Query"
  description: "Queries Snowflake for Conversations API usage metrics by customer."
  tags:
    - communications
    - snowflake
    - conversations
capability:
  exposes:
    - type: mcp
      namespace: twilio_conversations
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for Conversations API usage metrics by customer."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Analyzes customer usage patterns from Snowflake, generates cost optimization recommendations, and shares with the account team.

naftiko: "0.5"
info:
  label: "Twilio Cost Optimization Recommendation"
  description: "Analyzes customer usage patterns from Snowflake, generates cost optimization recommendations, and shares with the account team."
  tags:
    - billing
    - snowflake
    - salesforce
    - slack
    - optimization
capability:
  exposes:
    - type: mcp
      namespace: twilio_cost_optimiza
      port: 8080
      tools:
        - name: handle-event
          description: "Analyzes customer usage patterns from Snowflake, generates cost optimization recommendations, and shares with the account team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[billing] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "billing-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When usage patterns indicate churn risk, updates Salesforce health score, creates a follow-up task, and alerts the CSM via Slack.

naftiko: "0.5"
info:
  label: "Twilio Customer Churn Risk Alert"
  description: "When usage patterns indicate churn risk, updates Salesforce health score, creates a follow-up task, and alerts the CSM via Slack."
  tags:
    - crm
    - salesforce
    - snowflake
    - slack
    - customer-success
capability:
  exposes:
    - type: mcp
      namespace: twilio_customer_chur
      port: 8080
      tools:
        - name: handle-event
          description: "When usage patterns indicate churn risk, updates Salesforce health score, creates a follow-up task, and alerts the CSM via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[crm] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "crm-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Syncs customer health scores from Snowflake to Salesforce, creates follow-up tasks for at-risk accounts, and notifies CSMs.

naftiko: "0.5"
info:
  label: "Twilio Customer Health Score Sync"
  description: "Syncs customer health scores from Snowflake to Salesforce, creates follow-up tasks for at-risk accounts, and notifies CSMs."
  tags:
    - crm
    - snowflake
    - salesforce
    - slack
    - customer-success
capability:
  exposes:
    - type: mcp
      namespace: twilio_customer_heal
      port: 8080
      tools:
        - name: handle-event
          description: "Syncs customer health scores from Snowflake to Salesforce, creates follow-up tasks for at-risk accounts, and notifies CSMs."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[crm] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "crm-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates customer platform migrations by updating Salesforce, creating Jira tasks, and notifying account teams via Slack.

naftiko: "0.5"
info:
  label: "Twilio Customer Migration Orchestrator"
  description: "Orchestrates customer platform migrations by updating Salesforce, creating Jira tasks, and notifying account teams via Slack."
  tags:
    - crm
    - salesforce
    - jira
    - slack
    - migrations
capability:
  exposes:
    - type: mcp
      namespace: twilio_customer_migr
      port: 8080
      tools:
        - name: handle-event
          description: "Orchestrates customer platform migrations by updating Salesforce, creating Jira tasks, and notifying account teams via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[crm] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "crm-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When developer community sentiment drops, queries analytics from Snowflake, creates a Jira task, and alerts the DevRel team.

naftiko: "0.5"
info:
  label: "Twilio Developer Community Alert"
  description: "When developer community sentiment drops, queries analytics from Snowflake, creates a Jira task, and alerts the DevRel team."
  tags:
    - developer-experience
    - snowflake
    - jira
    - slack
    - community
capability:
  exposes:
    - type: mcp
      namespace: twilio_developer_com
      port: 8080
      tools:
        - name: handle-event
          description: "When developer community sentiment drops, queries analytics from Snowflake, creates a Jira task, and alerts the DevRel team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[developer-experience] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "developer-experience-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new developer signs up, provisions account resources, sends welcome emails via SendGrid, and logs in Snowflake.

naftiko: "0.5"
info:
  label: "Twilio Developer Onboarding Orchestrator"
  description: "When a new developer signs up, provisions account resources, sends welcome emails via SendGrid, and logs in Snowflake."
  tags:
    - developer-experience
    - snowflake
    - slack
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: twilio_developer_onb
      port: 8080
      tools:
        - name: handle-event
          description: "When a new developer signs up, provisions account resources, sends welcome emails via SendGrid, and logs in Snowflake."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[developer-experience] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "developer-experience-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors edge location performance from Datadog, creates Jira tickets for degraded locations, and alerts infrastructure.

naftiko: "0.5"
info:
  label: "Twilio Edge Location Performance Monitor"
  description: "Monitors edge location performance from Datadog, creates Jira tickets for degraded locations, and alerts infrastructure."
  tags:
    - infrastructure
    - datadog
    - jira
    - slack
    - edge
capability:
  exposes:
    - type: mcp
      namespace: twilio_edge_location
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors edge location performance from Datadog, creates Jira tickets for degraded locations, and alerts infrastructure."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[infrastructure] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "infrastructure-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns SIP trunk utilization and call quality metrics from Snowflake.

naftiko: "0.5"
info:
  label: "Twilio Elastic SIP Trunking Status"
  description: "Returns SIP trunk utilization and call quality metrics from Snowflake."
  tags:
    - communications
    - snowflake
    - sip
capability:
  exposes:
    - type: mcp
      namespace: twilio_elastic_sip_t
      port: 8080
      tools:
        - name: query-data
          description: "Returns SIP trunk utilization and call quality metrics from Snowflake."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When an enterprise customer support ticket breaches SLA, escalates via PagerDuty, updates Salesforce, and notifies the TAM.

naftiko: "0.5"
info:
  label: "Twilio Enterprise Support Escalation"
  description: "When an enterprise customer support ticket breaches SLA, escalates via PagerDuty, updates Salesforce, and notifies the TAM."
  tags:
    - crm
    - salesforce
    - pagerduty
    - slack
    - support
capability:
  exposes:
    - type: mcp
      namespace: twilio_enterprise_su
      port: 8080
      tools:
        - name: handle-event
          description: "When an enterprise customer support ticket breaches SLA, escalates via PagerDuty, updates Salesforce, and notifies the TAM."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[crm] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "crm-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns current agent availability and queue statistics for Twilio Flex.

naftiko: "0.5"
info:
  label: "Twilio Flex Agent Status Lookup"
  description: "Returns current agent availability and queue statistics for Twilio Flex."
  tags:
    - communications
    - twilio
    - contact-center
capability:
  exposes:
    - type: mcp
      namespace: twilio_flex_agent_st
      port: 8080
      tools:
        - name: query-data
          description: "Returns current agent availability and queue statistics for Twilio Flex."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When a Flex plugin is deployed, logs in ServiceNow, creates a Jira release note, and notifies the CX engineering team.

naftiko: "0.5"
info:
  label: "Twilio Flex Plugin Deployment Tracker"
  description: "When a Flex plugin is deployed, logs in ServiceNow, creates a Jira release note, and notifies the CX engineering team."
  tags:
    - communications
    - servicenow
    - jira
    - slack
    - contact-center
capability:
  exposes:
    - type: mcp
      namespace: twilio_flex_plugin_d
      port: 8080
      tools:
        - name: handle-event
          description: "When a Flex plugin is deployed, logs in ServiceNow, creates a Jira release note, and notifies the CX engineering team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Flex contact center queues exceed capacity, adjusts routing, creates a Jira ticket, and alerts the CX team via Slack.

naftiko: "0.5"
info:
  label: "Twilio Flex Queue Overflow Handler"
  description: "When Flex contact center queues exceed capacity, adjusts routing, creates a Jira ticket, and alerts the CX team via Slack."
  tags:
    - communications
    - jira
    - slack
    - contact-center
capability:
  exposes:
    - type: mcp
      namespace: twilio_flex_queue_ov
      port: 8080
      tools:
        - name: handle-event
          description: "When Flex contact center queues exceed capacity, adjusts routing, creates a Jira ticket, and alerts the CX team via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a global infrastructure health digest from Datadog, creates Jira tickets for issues, and posts to Slack.

naftiko: "0.5"
info:
  label: "Twilio Global Infrastructure Status Digest"
  description: "Generates a global infrastructure health digest from Datadog, creates Jira tickets for issues, and posts to Slack."
  tags:
    - infrastructure
    - datadog
    - jira
    - slack
    - global
capability:
  exposes:
    - type: mcp
      namespace: twilio_global_infras
      port: 8080
      tools:
        - name: handle-event
          description: "Generates a global infrastructure health digest from Datadog, creates Jira tickets for issues, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[infrastructure] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "infrastructure-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Assesses carrier readiness for new markets from Snowflake, creates Jira planning tasks, and notifies the expansion team.

naftiko: "0.5"
info:
  label: "Twilio International Expansion Readiness"
  description: "Assesses carrier readiness for new markets from Snowflake, creates Jira planning tasks, and notifies the expansion team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - international
capability:
  exposes:
    - type: mcp
      namespace: twilio_international
      port: 8080
      tools:
        - name: handle-event
          description: "Assesses carrier readiness for new markets from Snowflake, creates Jira planning tasks, and notifies the expansion team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Assists customers migrating between messaging channels, updates Salesforce records, creates Jira tasks, and posts progress.

naftiko: "0.5"
info:
  label: "Twilio Messaging Channel Migration Assistant"
  description: "Assists customers migrating between messaging channels, updates Salesforce records, creates Jira tasks, and posts progress."
  tags:
    - communications
    - salesforce
    - jira
    - slack
    - migrations
capability:
  exposes:
    - type: mcp
      namespace: twilio_messaging_cha
      port: 8080
      tools:
        - name: handle-event
          description: "Assists customers migrating between messaging channels, updates Salesforce records, creates Jira tasks, and posts progress."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks messaging compliance rates from Snowflake, creates Jira tasks for violations, and notifies the trust and safety team.

naftiko: "0.5"
info:
  label: "Twilio Messaging Compliance Checker"
  description: "Checks messaging compliance rates from Snowflake, creates Jira tasks for violations, and notifies the trust and safety team."
  tags:
    - compliance
    - snowflake
    - jira
    - slack
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: twilio_messaging_com
      port: 8080
      tools:
        - name: handle-event
          description: "Checks messaging compliance rates from Snowflake, creates Jira tasks for violations, and notifies the trust and safety team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[compliance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "compliance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Messaging Insights detects delivery anomalies, queries Snowflake for details, creates a Jira ticket, and alerts ops.

naftiko: "0.5"
info:
  label: "Twilio Messaging Insights Anomaly Handler"
  description: "When Messaging Insights detects delivery anomalies, queries Snowflake for details, creates a Jira ticket, and alerts ops."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: twilio_messaging_ins
      port: 8080
      tools:
        - name: handle-event
          description: "When Messaging Insights detects delivery anomalies, queries Snowflake for details, creates a Jira ticket, and alerts ops."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Orchestrates multi-channel campaigns across SMS, email, and WhatsApp, logs results in Snowflake, and reports to Slack.

naftiko: "0.5"
info:
  label: "Twilio Multi-Channel Campaign Orchestrator"
  description: "Orchestrates multi-channel campaigns across SMS, email, and WhatsApp, logs results in Snowflake, and reports to Slack."
  tags:
    - communications
    - snowflake
    - slack
    - marketing
capability:
  exposes:
    - type: mcp
      namespace: twilio_multi_channel
      port: 8080
      tools:
        - name: handle-event
          description: "Orchestrates multi-channel campaigns across SMS, email, and WhatsApp, logs results in Snowflake, and reports to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors phone number pool utilization from Snowflake, creates Jira procurement tasks for low inventory, and alerts the numbers team.

naftiko: "0.5"
info:
  label: "Twilio Number Pool Capacity Manager"
  description: "Monitors phone number pool utilization from Snowflake, creates Jira procurement tasks for low inventory, and alerts the numbers team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - phone-numbers
capability:
  exposes:
    - type: mcp
      namespace: twilio_number_pool_c
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors phone number pool utilization from Snowflake, creates Jira procurement tasks for low inventory, and alerts the numbers team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a number port request is submitted, validates eligibility, creates a Jira task, and notifies the provisioning team via Slack.

naftiko: "0.5"
info:
  label: "Twilio Number Porting Workflow"
  description: "When a number port request is submitted, validates eligibility, creates a Jira task, and notifies the provisioning team via Slack."
  tags:
    - communications
    - jira
    - slack
    - phone-numbers
capability:
  exposes:
    - type: mcp
      namespace: twilio_number_portin
      port: 8080
      tools:
        - name: handle-event
          description: "When a number port request is submitted, validates eligibility, creates a Jira task, and notifies the provisioning team via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors partner integration health from Datadog, creates Jira tickets for degraded integrations, and alerts the partnerships team.

naftiko: "0.5"
info:
  label: "Twilio Partner Integration Health Monitor"
  description: "Monitors partner integration health from Datadog, creates Jira tickets for degraded integrations, and alerts the partnerships team."
  tags:
    - integrations
    - datadog
    - jira
    - slack
    - partnerships
capability:
  exposes:
    - type: mcp
      namespace: twilio_partner_integ
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors partner integration health from Datadog, creates Jira tickets for degraded integrations, and alerts the partnerships team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[integrations] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "integrations-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Looks up phone number capabilities and carrier information via Twilio Lookup API.

naftiko: "0.5"
info:
  label: "Twilio Phone Number Lookup"
  description: "Looks up phone number capabilities and carrier information via Twilio Lookup API."
  tags:
    - communications
    - twilio
    - phone-numbers
capability:
  exposes:
    - type: mcp
      namespace: twilio_phone_number_
      port: 8080
      tools:
        - name: query-data
          description: "Looks up phone number capabilities and carrier information via Twilio Lookup API."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When a platform incident is detected, creates a PagerDuty incident, opens a Slack incident channel, and creates a ServiceNow record.

naftiko: "0.5"
info:
  label: "Twilio Platform Incident Response"
  description: "When a platform incident is detected, creates a PagerDuty incident, opens a Slack incident channel, and creates a ServiceNow record."
  tags:
    - operations
    - pagerduty
    - slack
    - servicenow
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: twilio_platform_inci
      port: 8080
      tools:
        - name: handle-event
          description: "When a platform incident is detected, creates a PagerDuty incident, opens a Slack incident channel, and creates a ServiceNow record."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[operations] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "operations-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks customer migration from Chat to Conversations, updates Salesforce records, creates Jira tasks, and posts progress to Slack.

naftiko: "0.5"
info:
  label: "Twilio Programmable Chat Migration Tracker"
  description: "Tracks customer migration from Chat to Conversations, updates Salesforce records, creates Jira tasks, and posts progress to Slack."
  tags:
    - communications
    - salesforce
    - jira
    - slack
    - migrations
capability:
  exposes:
    - type: mcp
      namespace: twilio_programmable_
      port: 8080
      tools:
        - name: handle-event
          description: "Tracks customer migration from Chat to Conversations, updates Salesforce records, creates Jira tasks, and posts progress to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns the delivery status and error codes for a Twilio message SID.

naftiko: "0.5"
info:
  label: "Twilio Programmable Messaging Status"
  description: "Returns the delivery status and error codes for a Twilio message SID."
  tags:
    - communications
    - twilio
    - messaging
capability:
  exposes:
    - type: mcp
      namespace: twilio_programmable_
      port: 8080
      tools:
        - name: query-data
          description: "Returns the delivery status and error codes for a Twilio message SID."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Generates a weekly regulatory compliance digest from Snowflake, creates Jira tasks for new requirements, and posts to Slack.

naftiko: "0.5"
info:
  label: "Twilio Regulatory Compliance Digest"
  description: "Generates a weekly regulatory compliance digest from Snowflake, creates Jira tasks for new requirements, and posts to Slack."
  tags:
    - compliance
    - snowflake
    - jira
    - slack
    - regulatory
capability:
  exposes:
    - type: mcp
      namespace: twilio_regulatory_co
      port: 8080
      tools:
        - name: handle-event
          description: "Generates a weekly regulatory compliance digest from Snowflake, creates Jira tasks for new requirements, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[compliance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "compliance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for revenue data, updates Salesforce forecasts, creates Jira finance tasks, and posts to Slack.

naftiko: "0.5"
info:
  label: "Twilio Revenue Recognition Workflow"
  description: "Queries Snowflake for revenue data, updates Salesforce forecasts, creates Jira finance tasks, and posts to Slack."
  tags:
    - finance
    - snowflake
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: twilio_revenue_recog
      port: 8080
      tools:
        - name: handle-event
          description: "Queries Snowflake for revenue data, updates Salesforce forecasts, creates Jira finance tasks, and posts to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[finance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "finance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks SDK version adoption from Snowflake, creates Jira tasks for deprecated versions, and notifies the SDK team via Slack.

naftiko: "0.5"
info:
  label: "Twilio SDK Adoption Tracker"
  description: "Tracks SDK version adoption from Snowflake, creates Jira tasks for deprecated versions, and notifies the SDK team via Slack."
  tags:
    - developer-experience
    - snowflake
    - jira
    - slack
    - sdk
capability:
  exposes:
    - type: mcp
      namespace: twilio_sdk_adoption_
      port: 8080
      tools:
        - name: handle-event
          description: "Tracks SDK version adoption from Snowflake, creates Jira tasks for deprecated versions, and notifies the SDK team via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[developer-experience] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "developer-experience-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks security audit compliance status from Snowflake, creates Jira remediation tasks, and notifies the security team.

naftiko: "0.5"
info:
  label: "Twilio Security Audit Compliance Tracker"
  description: "Tracks security audit compliance status from Snowflake, creates Jira remediation tasks, and notifies the security team."
  tags:
    - security
    - snowflake
    - jira
    - slack
    - audit
capability:
  exposes:
    - type: mcp
      namespace: twilio_security_audi
      port: 8080
      tools:
        - name: handle-event
          description: "Tracks security audit compliance status from Snowflake, creates Jira remediation tasks, and notifies the security team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[security] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "security-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Segment data pipeline health from Datadog, creates Jira tickets for failures, and alerts the data team via Slack.

naftiko: "0.5"
info:
  label: "Twilio Segment Data Pipeline Monitor"
  description: "Monitors Segment data pipeline health from Datadog, creates Jira tickets for failures, and alerts the data team via Slack."
  tags:
    - analytics
    - datadog
    - jira
    - slack
    - customer-data
capability:
  exposes:
    - type: mcp
      namespace: twilio_segment_data_
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors Segment data pipeline health from Datadog, creates Jira tickets for failures, and alerts the data team via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[analytics] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "analytics-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns a unified customer profile from Twilio Segment by user ID.

naftiko: "0.5"
info:
  label: "Twilio Segment Profile Lookup"
  description: "Returns a unified customer profile from Twilio Segment by user ID."
  tags:
    - analytics
    - twilio
    - customer-data
capability:
  exposes:
    - type: mcp
      namespace: twilio_segment_profi
      port: 8080
      tools:
        - name: query-data
          description: "Returns a unified customer profile from Twilio Segment by user ID."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Monitors Segment warehouse sync jobs from Snowflake, creates Jira tickets for sync failures, and alerts the data team.

naftiko: "0.5"
info:
  label: "Twilio Segment Warehouse Sync Monitor"
  description: "Monitors Segment warehouse sync jobs from Snowflake, creates Jira tickets for sync failures, and alerts the data team."
  tags:
    - analytics
    - snowflake
    - jira
    - slack
    - customer-data
capability:
  exposes:
    - type: mcp
      namespace: twilio_segment_wareh
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors Segment warehouse sync jobs from Snowflake, creates Jira tickets for sync failures, and alerts the data team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[analytics] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "analytics-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When SendGrid bounce rates spike, queries patterns from Snowflake, creates a Jira investigation, and alerts the email team.

naftiko: "0.5"
info:
  label: "Twilio SendGrid Bounce Rate Handler"
  description: "When SendGrid bounce rates spike, queries patterns from Snowflake, creates a Jira investigation, and alerts the email team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - email
capability:
  exposes:
    - type: mcp
      namespace: twilio_sendgrid_boun
      port: 8080
      tools:
        - name: handle-event
          description: "When SendGrid bounce rates spike, queries patterns from Snowflake, creates a Jira investigation, and alerts the email team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Analyzes deliverability metrics from Snowflake, creates Jira optimization tasks, and posts recommendations to Slack.

naftiko: "0.5"
info:
  label: "Twilio SendGrid Deliverability Optimization"
  description: "Analyzes deliverability metrics from Snowflake, creates Jira optimization tasks, and posts recommendations to Slack."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - email
capability:
  exposes:
    - type: mcp
      namespace: twilio_sendgrid_deli
      port: 8080
      tools:
        - name: handle-event
          description: "Analyzes deliverability metrics from Snowflake, creates Jira optimization tasks, and posts recommendations to Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns email delivery rates, bounce rates, and open rates from SendGrid.

naftiko: "0.5"
info:
  label: "Twilio SendGrid Delivery Metrics"
  description: "Returns email delivery rates, bounce rates, and open rates from SendGrid."
  tags:
    - communications
    - twilio
    - email
capability:
  exposes:
    - type: mcp
      namespace: twilio_sendgrid_deli
      port: 8080
      tools:
        - name: query-data
          description: "Returns email delivery rates, bounce rates, and open rates from SendGrid."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Monitors SendGrid IP reputation scores from Snowflake, creates Jira tasks for degraded IPs, and alerts the email team.

naftiko: "0.5"
info:
  label: "Twilio SendGrid IP Reputation Monitor"
  description: "Monitors SendGrid IP reputation scores from Snowflake, creates Jira tasks for degraded IPs, and alerts the email team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - email
capability:
  exposes:
    - type: mcp
      namespace: twilio_sendgrid_ip_r
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors SendGrid IP reputation scores from Snowflake, creates Jira tasks for degraded IPs, and alerts the email team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When SIP trunk utilization exceeds threshold, queries Snowflake for trends, creates a Jira capacity task, and alerts the voice team.

naftiko: "0.5"
info:
  label: "Twilio SIP Trunk Capacity Alert"
  description: "When SIP trunk utilization exceeds threshold, queries Snowflake for trends, creates a Jira capacity task, and alerts the voice team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - sip
capability:
  exposes:
    - type: mcp
      namespace: twilio_sip_trunk_cap
      port: 8080
      tools:
        - name: handle-event
          description: "When SIP trunk utilization exceeds threshold, queries Snowflake for trends, creates a Jira capacity task, and alerts the voice team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When SMS delivery rates drop below threshold, queries carrier data, creates a Jira ticket, and alerts the messaging team via Slack.

naftiko: "0.5"
info:
  label: "Twilio SMS Delivery Failure Handler"
  description: "When SMS delivery rates drop below threshold, queries carrier data, creates a Jira ticket, and alerts the messaging team via Slack."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - sms
capability:
  exposes:
    - type: mcp
      namespace: twilio_sms_delivery_
      port: 8080
      tools:
        - name: handle-event
          description: "When SMS delivery rates drop below threshold, queries carrier data, creates a Jira ticket, and alerts the messaging team via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for SMS delivery rates by country and carrier.

naftiko: "0.5"
info:
  label: "Twilio SMS Delivery Rate Query"
  description: "Queries Snowflake for SMS delivery rates by country and carrier."
  tags:
    - communications
    - snowflake
    - sms
capability:
  exposes:
    - type: mcp
      namespace: twilio_sms_delivery_
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for SMS delivery rates by country and carrier."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When a Studio flow execution error rate spikes, queries Snowflake for patterns, creates a Jira bug, and alerts the low-code team.

naftiko: "0.5"
info:
  label: "Twilio Studio Flow Error Handler"
  description: "When a Studio flow execution error rate spikes, queries Snowflake for patterns, creates a Jira bug, and alerts the low-code team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - studio
capability:
  exposes:
    - type: mcp
      namespace: twilio_studio_flow_e
      port: 8080
      tools:
        - name: handle-event
          description: "When a Studio flow execution error rate spikes, queries Snowflake for patterns, creates a Jira bug, and alerts the low-code team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns connectivity status and data usage for Twilio Super SIM fleet.

naftiko: "0.5"
info:
  label: "Twilio Super SIM Connectivity Check"
  description: "Returns connectivity status and data usage for Twilio Super SIM fleet."
  tags:
    - communications
    - twilio
    - iot
capability:
  exposes:
    - type: mcp
      namespace: twilio_super_sim_con
      port: 8080
      tools:
        - name: query-data
          description: "Returns connectivity status and data usage for Twilio Super SIM fleet."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Monitors IoT SIM fleet health from Snowflake, creates Jira tickets for connectivity issues, and alerts the IoT team.

naftiko: "0.5"
info:
  label: "Twilio Super SIM Fleet Health Monitor"
  description: "Monitors IoT SIM fleet health from Snowflake, creates Jira tickets for connectivity issues, and alerts the IoT team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - iot
capability:
  exposes:
    - type: mcp
      namespace: twilio_super_sim_fle
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors IoT SIM fleet health from Snowflake, creates Jira tickets for connectivity issues, and alerts the IoT team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Tracks toll-free verification status from Snowflake, creates Jira tasks for rejections, and notifies the compliance team.

naftiko: "0.5"
info:
  label: "Twilio Toll-Free Verification Tracker"
  description: "Tracks toll-free verification status from Snowflake, creates Jira tasks for rejections, and notifies the compliance team."
  tags:
    - compliance
    - snowflake
    - jira
    - slack
    - phone-numbers
capability:
  exposes:
    - type: mcp
      namespace: twilio_toll_free_ver
      port: 8080
      tools:
        - name: handle-event
          description: "Tracks toll-free verification status from Snowflake, creates Jira tasks for rejections, and notifies the compliance team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[compliance] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "compliance-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When account usage spikes abnormally, queries patterns from Snowflake, creates a Jira alert, and notifies the account team via Slack.

naftiko: "0.5"
info:
  label: "Twilio Usage Anomaly Detection"
  description: "When account usage spikes abnormally, queries patterns from Snowflake, creates a Jira alert, and notifies the account team via Slack."
  tags:
    - billing
    - snowflake
    - jira
    - slack
    - fraud
capability:
  exposes:
    - type: mcp
      namespace: twilio_usage_anomaly
      port: 8080
      tools:
        - name: handle-event
          description: "When account usage spikes abnormally, queries patterns from Snowflake, creates a Jira alert, and notifies the account team via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[billing] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "billing-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for Verify API fraud attempt rates and success metrics.

naftiko: "0.5"
info:
  label: "Twilio Verify Fraud Metrics Query"
  description: "Queries Snowflake for Verify API fraud attempt rates and success metrics."
  tags:
    - security
    - snowflake
    - verification
capability:
  exposes:
    - type: mcp
      namespace: twilio_verify_fraud_
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for Verify API fraud attempt rates and success metrics."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When Verify fraud attempts spike, queries patterns from Snowflake, creates a ServiceNow incident, and pages the security team.

naftiko: "0.5"
info:
  label: "Twilio Verify Fraud Spike Handler"
  description: "When Verify fraud attempts spike, queries patterns from Snowflake, creates a ServiceNow incident, and pages the security team."
  tags:
    - security
    - snowflake
    - servicenow
    - pagerduty
    - fraud
capability:
  exposes:
    - type: mcp
      namespace: twilio_verify_fraud_
      port: 8080
      tools:
        - name: handle-event
          description: "When Verify fraud attempts spike, queries patterns from Snowflake, creates a ServiceNow incident, and pages the security team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[security] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "security-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When video quality metrics degrade, queries Snowflake for affected customers, creates a Jira ticket, and notifies the video team.

naftiko: "0.5"
info:
  label: "Twilio Video Quality Investigation"
  description: "When video quality metrics degrade, queries Snowflake for affected customers, creates a Jira ticket, and notifies the video team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - video
capability:
  exposes:
    - type: mcp
      namespace: twilio_video_quality
      port: 8080
      tools:
        - name: handle-event
          description: "When video quality metrics degrade, queries Snowflake for affected customers, creates a Jira ticket, and notifies the video team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for video room usage metrics including participant minutes.

naftiko: "0.5"
info:
  label: "Twilio Video Room Usage Query"
  description: "Queries Snowflake for video room usage metrics including participant minutes."
  tags:
    - communications
    - snowflake
    - video
capability:
  exposes:
    - type: mcp
      namespace: twilio_video_room_us
      port: 8080
      tools:
        - name: query-data
          description: "Queries Snowflake for video room usage metrics including participant minutes."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Returns voice call quality metrics including MOS scores from Snowflake.

naftiko: "0.5"
info:
  label: "Twilio Voice Call Quality Check"
  description: "Returns voice call quality metrics including MOS scores from Snowflake."
  tags:
    - communications
    - snowflake
    - voice
capability:
  exposes:
    - type: mcp
      namespace: twilio_voice_call_qu
      port: 8080
      tools:
        - name: query-data
          description: "Returns voice call quality metrics including MOS scores from Snowflake."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

When voice call quality drops, queries Snowflake for affected regions, creates a PagerDuty incident, and notifies via Slack.

naftiko: "0.5"
info:
  label: "Twilio Voice Quality Degradation Alert"
  description: "When voice call quality drops, queries Snowflake for affected regions, creates a PagerDuty incident, and notifies via Slack."
  tags:
    - communications
    - snowflake
    - pagerduty
    - slack
    - voice
capability:
  exposes:
    - type: mcp
      namespace: twilio_voice_quality
      port: 8080
      tools:
        - name: handle-event
          description: "When voice call quality drops, queries Snowflake for affected regions, creates a PagerDuty incident, and notifies via Slack."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When webhook delivery failures spike, queries Snowflake for affected customers, creates a Jira ticket, and notifies support.

naftiko: "0.5"
info:
  label: "Twilio Webhook Failure Investigation"
  description: "When webhook delivery failures spike, queries Snowflake for affected customers, creates a Jira ticket, and notifies support."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - webhooks
capability:
  exposes:
    - type: mcp
      namespace: twilio_webhook_failu
      port: 8080
      tools:
        - name: handle-event
          description: "When webhook delivery failures spike, queries Snowflake for affected customers, creates a Jira ticket, and notifies support."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors WhatsApp Business API health from Snowflake, creates Jira tickets for delivery issues, and alerts the messaging team.

naftiko: "0.5"
info:
  label: "Twilio WhatsApp Business API Health"
  description: "Monitors WhatsApp Business API health from Snowflake, creates Jira tickets for delivery issues, and alerts the messaging team."
  tags:
    - communications
    - snowflake
    - jira
    - slack
    - whatsapp
capability:
  exposes:
    - type: mcp
      namespace: twilio_whatsapp_busi
      port: 8080
      tools:
        - name: handle-event
          description: "Monitors WhatsApp Business API health from Snowflake, creates Jira tickets for delivery issues, and alerts the messaging team."
          inputParameters:
            - name: event_id
              in: body
              type: string
              description: "The triggering event identifier."
            - name: context
              in: body
              type: string
              description: "Additional context for the event."
          steps:
            - name: gather-data
              type: call
              call: "snowflake-api.run-query"
              with:
                event_id: "{{event_id}}"
            - name: create-ticket
              type: call
              call: "jira-api.create-issue"
              with:
                project: "OPS"
                issuetype: "Task"
                summary: "[communications] {{event_id}} — {{context}}"
            - name: notify-team
              type: call
              call: "slack-api.post-message"
              with:
                channel: "communications-ops"
                text: "Alert: {{event_id}} | {{context}} | Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST
    - type: http
      namespace: jira-api
      baseUri: "https://twilio.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-api
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Returns current engineering headcount and open positions from Workday.

naftiko: "0.5"
info:
  label: "Workday Engineering Headcount Lookup"
  description: "Returns current engineering headcount and open positions from Workday."
  tags:
    - hr
    - workday
    - workforce
capability:
  exposes:
    - type: mcp
      namespace: workday_engineering_
      port: 8080
      tools:
        - name: query-data
          description: "Returns current engineering headcount and open positions from Workday."
          inputParameters:
            - name: query_param
              in: body
              type: string
              description: "The query parameter."
          call: "snowflake-api.run-query"
          with:
            query_param: "{{query_param}}"
          outputParameters:
            - name: results
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: snowflake-api
      baseUri: "https://twilio.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: run-query
              method: POST

Initiates the biweekly payroll period close in Workday, validates completion status, and notifies the payroll team via Slack.

naftiko: "0.5"
info:
  label: "Workday Payroll Period Close"
  description: "Initiates the biweekly payroll period close in Workday, validates completion status, and notifies the payroll team via Slack."
  tags:
    - hr
    - payroll
    - workday
    - slack
capability:
  exposes:
    - type: mcp
      namespace: payroll-ops
      port: 8080
      tools:
        - name: close-payroll-period
          description: "Given a payroll period ID, trigger the period close in Workday, verify completion status, and notify the payroll team in Slack with the close summary."
          inputParameters:
            - name: period_id
              in: body
              type: string
              description: "The Workday payroll period ID to close."
            - name: period_name
              in: body
              type: string
              description: "Human-readable name for the payroll period (e.g., 2026-W12)."
            - name: payroll_channel
              in: body
              type: string
              description: "Slack channel for the payroll team."
          steps:
            - name: close-period
              type: call
              call: "workday-payroll.close-payroll-period"
              with:
                periodId: "{{period_id}}"
            - name: notify-payroll-team
              type: call
              call: "slack-payroll.post-message"
              with:
                channel: "{{payroll_channel}}"
                text: "Payroll period {{period_name}} closed. Status: {{close-period.status}}. Employees processed: {{close-period.employee_count}}. Total gross: ${{close-period.total_gross}}"
  consumes:
    - type: http
      namespace: workday-payroll
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: payroll-periods
          path: "/payrollPeriods/{{periodId}}/close"
          inputParameters:
            - name: periodId
              in: path
          operations:
            - name: close-payroll-period
              method: POST
    - type: http
      namespace: slack-payroll
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls customer satisfaction scores from Zendesk for a given week and posts a CSAT summary by team and agent to the support leadership Slack channel.

naftiko: "0.5"
info:
  label: "Zendesk Ticket CSAT Digest"
  description: "Pulls customer satisfaction scores from Zendesk for a given week and posts a CSAT summary by team and agent to the support leadership Slack channel."
  tags:
    - customer-support
    - csat
    - zendesk
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: support-reporting
      port: 8080
      tools:
        - name: digest-csat-scores
          description: "Given a Zendesk satisfaction reporting period, retrieve CSAT scores by team and post a weekly satisfaction summary to the support leadership Slack channel."
          inputParameters:
            - name: start_date
              in: body
              type: string
              description: "Start date of the CSAT reporting period in YYYY-MM-DD format."
            - name: end_date
              in: body
              type: string
              description: "End date of the CSAT reporting period in YYYY-MM-DD format."
            - name: support_leadership_channel
              in: body
              type: string
              description: "Slack channel for support leadership digest."
          steps:
            - name: get-satisfaction-ratings
              type: call
              call: "zendesk-csat.get-satisfaction-ratings"
              with:
                start_time: "{{start_date}}"
                end_time: "{{end_date}}"
            - name: post-csat-digest
              type: call
              call: "slack-csat.post-message"
              with:
                channel: "{{support_leadership_channel}}"
                text: "CSAT Report ({{start_date}} to {{end_date}}): Overall score: {{get-satisfaction-ratings.score}}% | Good: {{get-satisfaction-ratings.good_count}} | Bad: {{get-satisfaction-ratings.bad_count}} | Total: {{get-satisfaction-ratings.total}}"
  consumes:
    - type: http
      namespace: zendesk-csat
      baseUri: "https://twilio.zendesk.com/api/v2"
      authentication:
        type: basic
        username: "$secrets.zendesk_user"
        password: "$secrets.zendesk_api_token"
      resources:
        - name: satisfaction-ratings
          path: "/satisfaction_ratings"
          inputParameters:
            - name: start_time
              in: query
            - name: end_time
              in: query
          operations:
            - name: get-satisfaction-ratings
              method: GET
    - type: http
      namespace: slack-csat
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST