Deliveroo Capabilities

Retrieves a funnel analysis from Amplitude for a given event sequence and posts the conversion rates to Slack.

naftiko: "0.5"
info:
  label: "Amplitude Funnel Analysis Report"
  description: "Retrieves a funnel analysis from Amplitude for a given event sequence and posts the conversion rates to Slack."
  tags:
    - analytics
    - product
    - amplitude
    - slack
capability:
  exposes:
    - type: mcp
      namespace: product-analytics
      port: 8080
      tools:
        - name: get-funnel-report
          description: "Given an Amplitude funnel ID, fetch conversion rates and post to the product analytics Slack channel."
          inputParameters:
            - name: funnel_id
              in: body
              type: string
              description: "Amplitude funnel chart ID."
          steps:
            - name: get-funnel
              type: call
              call: amplitude.get-funnel
              with:
                chart_id: "{{funnel_id}}"
            - name: post-report
              type: call
              call: slack.post-message
              with:
                channel: "product-analytics"
                text: "Funnel report: {{get-funnel.conversion_rate}}% overall conversion"
  consumes:
    - type: http
      namespace: amplitude
      baseUri: "https://amplitude.com/api/3"
      authentication:
        type: basic
        username: "$secrets.amplitude_api_key"
        password: "$secrets.amplitude_secret_key"
      resources:
        - name: funnels
          path: "/chart/{{chart_id}}/query"
          inputParameters:
            - name: chart_id
              in: path
          operations:
            - name: get-funnel
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When AWS cost anomaly detection fires, annotates Datadog, creates a Jira cost-review task, and posts an alert to the FinOps Slack channel.

naftiko: "0.5"
info:
  label: "AWS Cloud Cost Anomaly Alert"
  description: "When AWS cost anomaly detection fires, annotates Datadog, creates a Jira cost-review task, and posts an alert to the FinOps Slack channel."
  tags:
    - finops
    - cloud
    - aws
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: finops
      port: 8080
      tools:
        - name: handle-aws-cost-anomaly
          description: "Given an AWS cost anomaly alert with service and overage amount, create a Datadog event, open a Jira cost-review task, and notify the FinOps Slack channel."
          inputParameters:
            - name: anomaly_id
              in: body
              type: string
              description: "AWS Cost Anomaly Detection anomaly ID."
            - name: aws_service
              in: body
              type: string
              description: "AWS service name with the anomalous spend (e.g. EC2, RDS)."
            - name: estimated_overage_usd
              in: body
              type: number
              description: "Estimated overage amount in USD."
          steps:
            - name: annotate-datadog
              type: call
              call: datadog.create-event
              with:
                title: "AWS Cost Anomaly: {{aws_service}}"
                text: "Anomaly {{anomaly_id}} — estimated overage: ${{estimated_overage_usd}}"
                alert_type: warning
            - name: create-review-task
              type: call
              call: jira.create-issue
              with:
                project_key: FIN
                issuetype: Task
                summary: "AWS cost anomaly review: {{aws_service}} — ${{estimated_overage_usd}}"
                description: "Anomaly ID: {{anomaly_id}}\nService: {{aws_service}}\nEstimated overage: ${{estimated_overage_usd}}\nDatadog: {{annotate-datadog.url}}"
            - name: notify-finops
              type: call
              call: slack.post-message
              with:
                channel: finops-alerts
                text: "AWS Cost Anomaly: {{aws_service}} | Overage: ${{estimated_overage_usd}} | Jira: {{create-review-task.key}} | Datadog: {{annotate-datadog.url}}"
  consumes:
    - 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: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current state of an AWS CloudWatch alarm by alarm name.

naftiko: "0.5"
info:
  label: "AWS CloudWatch Alarm Status"
  description: "Retrieves the current state of an AWS CloudWatch alarm by alarm name."
  tags:
    - monitoring
    - cloud
    - aws
    - cloudwatch
capability:
  exposes:
    - type: mcp
      namespace: cloud-ops
      port: 8080
      tools:
        - name: get-alarm-status
          description: "Given a CloudWatch alarm name, return the current state, reason, and last updated timestamp."
          inputParameters:
            - name: alarm_name
              in: body
              type: string
              description: "CloudWatch alarm name."
          call: cloudwatch.describe-alarm
          with:
            alarm_name: "{{alarm_name}}"
          outputParameters:
            - name: state
              type: string
              mapping: "$.MetricAlarms[0].StateValue"
            - name: reason
              type: string
              mapping: "$.MetricAlarms[0].StateReason"
  consumes:
    - type: http
      namespace: cloudwatch
      baseUri: "https://monitoring.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: alarms
          path: "/"
          operations:
            - name: describe-alarm
              method: POST

Retrieves AWS cost data for a given service and time period from Cost Explorer.

naftiko: "0.5"
info:
  label: "AWS Cost Explorer Report"
  description: "Retrieves AWS cost data for a given service and time period from Cost Explorer."
  tags:
    - finops
    - cloud
    - aws
capability:
  exposes:
    - type: mcp
      namespace: finops
      port: 8080
      tools:
        - name: get-cost-report
          description: "Given a service name and date range, return the AWS cost breakdown from Cost Explorer."
          inputParameters:
            - name: service
              in: body
              type: string
              description: "AWS service name filter."
            - name: start_date
              in: body
              type: string
              description: "Start date (YYYY-MM-DD)."
            - name: end_date
              in: body
              type: string
              description: "End date (YYYY-MM-DD)."
          call: cost-explorer.get-cost
          with:
            service: "{{service}}"
            start: "{{start_date}}"
            end: "{{end_date}}"
          outputParameters:
            - name: total_cost
              type: string
              mapping: "$.ResultsByTime[0].Total.UnblendedCost.Amount"
            - name: currency
              type: string
              mapping: "$.ResultsByTime[0].Total.UnblendedCost.Unit"
  consumes:
    - type: http
      namespace: cost-explorer
      baseUri: "https://ce.us-east-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: costs
          path: "/"
          operations:
            - name: get-cost
              method: POST

Retrieves an order record from DynamoDB by order ID, returning status, restaurant, and delivery details.

naftiko: "0.5"
info:
  label: "AWS DynamoDB Order Lookup"
  description: "Retrieves an order record from DynamoDB by order ID, returning status, restaurant, and delivery details."
  tags:
    - data
    - orders
    - aws
    - dynamodb
capability:
  exposes:
    - type: mcp
      namespace: order-ops
      port: 8080
      tools:
        - name: get-order
          description: "Given an order ID, fetch the order record from DynamoDB. Returns status, restaurant name, and delivery ETA."
          inputParameters:
            - name: order_id
              in: body
              type: string
              description: "Deliveroo order ID."
          call: dynamodb.get-item
          with:
            table: "Orders"
            key:
              order_id: "{{order_id}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.Item.status.S"
            - name: restaurant
              type: string
              mapping: "$.Item.restaurant_name.S"
            - name: delivery_eta
              type: string
              mapping: "$.Item.delivery_eta.S"
  consumes:
    - type: http
      namespace: dynamodb
      baseUri: "https://dynamodb.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: items
          path: "/"
          operations:
            - name: get-item
              method: POST

Retrieves the status of an Amazon ECS service, returning running task count, desired count, and deployment status.

naftiko: "0.5"
info:
  label: "AWS ECS Service Status"
  description: "Retrieves the status of an Amazon ECS service, returning running task count, desired count, and deployment status."
  tags:
    - infrastructure
    - containers
    - aws
    - amazon-ecs
capability:
  exposes:
    - type: mcp
      namespace: platform-ops
      port: 8080
      tools:
        - name: get-ecs-service-status
          description: "Given an ECS cluster and service name, return the running task count, desired count, and latest deployment status."
          inputParameters:
            - name: cluster
              in: body
              type: string
              description: "ECS cluster name."
            - name: service
              in: body
              type: string
              description: "ECS service name."
          call: ecs.describe-service
          with:
            cluster: "{{cluster}}"
            service: "{{service}}"
          outputParameters:
            - name: running_count
              type: integer
              mapping: "$.services[0].runningCount"
            - name: desired_count
              type: integer
              mapping: "$.services[0].desiredCount"
            - name: deployment_status
              type: string
              mapping: "$.services[0].deployments[0].rolloutState"
  consumes:
    - type: http
      namespace: ecs
      baseUri: "https://ecs.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: services
          path: "/"
          operations:
            - name: describe-service
              method: POST

Invokes an AWS Lambda function to reprocess a failed order and returns the processing result.

naftiko: "0.5"
info:
  label: "AWS Lambda Order Processor Invoke"
  description: "Invokes an AWS Lambda function to reprocess a failed order and returns the processing result."
  tags:
    - engineering
    - serverless
    - aws
    - aws-lambda
capability:
  exposes:
    - type: mcp
      namespace: order-ops
      port: 8080
      tools:
        - name: reprocess-order
          description: "Given an order ID, invoke the order reprocessing Lambda function and return the result."
          inputParameters:
            - name: order_id
              in: body
              type: string
              description: "Order ID to reprocess."
          call: lambda.invoke-function
          with:
            function_name: "order-reprocessor"
            payload: "{\"order_id\": \"{{order_id}}\"}"
          outputParameters:
            - name: status_code
              type: integer
              mapping: "$.StatusCode"
            - name: result
              type: string
              mapping: "$.Payload"
  consumes:
    - type: http
      namespace: lambda
      baseUri: "https://lambda.eu-west-1.amazonaws.com/2015-03-31"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: functions
          path: "/functions/order-reprocessor/invocations"
          operations:
            - name: invoke-function
              method: POST

Creates an on-demand snapshot of an AWS RDS database instance and posts confirmation to the DBA Slack channel.

naftiko: "0.5"
info:
  label: "AWS RDS Snapshot Creation"
  description: "Creates an on-demand snapshot of an AWS RDS database instance and posts confirmation to the DBA Slack channel."
  tags:
    - data
    - database
    - aws
    - slack
capability:
  exposes:
    - type: mcp
      namespace: dba-ops
      port: 8080
      tools:
        - name: create-rds-snapshot
          description: "Given an RDS instance ID, create a manual snapshot and notify the DBA Slack channel."
          inputParameters:
            - name: db_instance_id
              in: body
              type: string
              description: "RDS instance identifier."
            - name: snapshot_suffix
              in: body
              type: string
              description: "Suffix for snapshot identifier."
          steps:
            - name: create-snapshot
              type: call
              call: rds.create-snapshot
              with:
                db_instance_id: "{{db_instance_id}}"
                snapshot_id: "{{db_instance_id}}-{{snapshot_suffix}}"
            - name: notify-dba
              type: call
              call: slack.post-message
              with:
                channel: "dba-ops"
                text: "RDS snapshot created: {{db_instance_id}}-{{snapshot_suffix}}"
  consumes:
    - type: http
      namespace: rds
      baseUri: "https://rds.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: snapshots
          path: "/"
          operations:
            - name: create-snapshot
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a pre-signed S3 URL for a data export file and sends it to the requester via Slack direct message.

naftiko: "0.5"
info:
  label: "AWS S3 Data Export"
  description: "Generates a pre-signed S3 URL for a data export file and sends it to the requester via Slack direct message."
  tags:
    - data
    - cloud
    - amazon-s3
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: share-data-export
          description: "Given an S3 bucket, key, and Slack user ID, generate a pre-signed download URL and send it as a Slack DM."
          inputParameters:
            - name: bucket
              in: body
              type: string
              description: "S3 bucket name."
            - name: key
              in: body
              type: string
              description: "S3 object key."
            - name: slack_user_id
              in: body
              type: string
              description: "Slack user ID for the DM."
          steps:
            - name: generate-url
              type: call
              call: s3.get-presigned-url
              with:
                bucket: "{{bucket}}"
                key: "{{key}}"
                expires_in: 3600
            - name: send-dm
              type: call
              call: slack.post-message
              with:
                channel: "{{slack_user_id}}"
                text: "Your data export is ready: {{generate-url.url}} (expires in 1 hour)"
  consumes:
    - type: http
      namespace: s3
      baseUri: "https://s3.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: objects
          path: "/{{bucket}}/{{key}}"
          inputParameters:
            - name: bucket
              in: path
            - name: key
              in: path
          operations:
            - name: get-presigned-url
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Triggers rotation for an AWS Secrets Manager secret and posts confirmation to the security Slack channel.

naftiko: "0.5"
info:
  label: "AWS Secrets Manager Rotation"
  description: "Triggers rotation for an AWS Secrets Manager secret and posts confirmation to the security Slack channel."
  tags:
    - security
    - cloud
    - aws
    - slack
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: rotate-secret
          description: "Given a Secrets Manager secret name, trigger rotation and notify the security Slack channel."
          inputParameters:
            - name: secret_name
              in: body
              type: string
              description: "AWS Secrets Manager secret name."
          steps:
            - name: trigger-rotation
              type: call
              call: secretsmanager.rotate-secret
              with:
                secret_id: "{{secret_name}}"
            - name: notify-security
              type: call
              call: slack.post-message
              with:
                channel: "security-ops"
                text: "Secret rotation triggered for: {{secret_name}} | Version: {{trigger-rotation.version_id}}"
  consumes:
    - type: http
      namespace: secretsmanager
      baseUri: "https://secretsmanager.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: secrets
          path: "/"
          operations:
            - name: rotate-secret
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks the approximate message count in an SQS queue and returns the depth for monitoring.

naftiko: "0.5"
info:
  label: "AWS SQS Queue Depth Monitor"
  description: "Checks the approximate message count in an SQS queue and returns the depth for monitoring."
  tags:
    - engineering
    - messaging
    - aws
    - amazon-sqs
capability:
  exposes:
    - type: mcp
      namespace: platform-ops
      port: 8080
      tools:
        - name: get-queue-depth
          description: "Given an SQS queue URL, return the approximate number of messages available and in-flight."
          inputParameters:
            - name: queue_url
              in: body
              type: string
              description: "SQS queue URL."
          call: sqs.get-queue-attributes
          with:
            queue_url: "{{queue_url}}"
          outputParameters:
            - name: messages_available
              type: integer
              mapping: "$.Attributes.ApproximateNumberOfMessages"
            - name: messages_in_flight
              type: integer
              mapping: "$.Attributes.ApproximateNumberOfMessagesNotVisible"
  consumes:
    - type: http
      namespace: sqs
      baseUri: "https://sqs.eu-west-1.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: queues
          path: "/"
          operations:
            - name: get-queue-attributes
              method: POST

Sends a targeted push notification to a customer segment via Braze and logs delivery metrics to Snowflake.

naftiko: "0.5"
info:
  label: "Braze Push Notification Send"
  description: "Sends a targeted push notification to a customer segment via Braze and logs delivery metrics to Snowflake."
  tags:
    - marketing
    - customer-engagement
    - braze
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: marketing-ops
      port: 8080
      tools:
        - name: send-push-notification
          description: "Given a Braze segment ID and message content, send a push notification and log metrics to Snowflake."
          inputParameters:
            - name: segment_id
              in: body
              type: string
              description: "Braze segment ID."
            - name: title
              in: body
              type: string
              description: "Push notification title."
            - name: body
              in: body
              type: string
              description: "Push notification body."
          steps:
            - name: send-push
              type: call
              call: braze.send-campaign
              with:
                segment_id: "{{segment_id}}"
                title: "{{title}}"
                body: "{{body}}"
            - name: log-metrics
              type: call
              call: snowflake.insert-row
              with:
                table: "PUSH_NOTIFICATION_LOG"
                values:
                  segment_id: "{{segment_id}}"
                  dispatch_id: "{{send-push.dispatch_id}}"
  consumes:
    - type: http
      namespace: braze
      baseUri: "https://rest.fra-02.braze.eu"
      authentication:
        type: bearer
        token: "$secrets.braze_api_key"
      resources:
        - name: campaigns
          path: "/campaigns/trigger/send"
          operations:
            - name: send-campaign
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: insert-row
              method: POST

Updates a Cloudflare rate limiting rule for a zone and notifies the security team via Slack.

naftiko: "0.5"
info:
  label: "Cloudflare Rate Limit Update"
  description: "Updates a Cloudflare rate limiting rule for a zone and notifies the security team via Slack."
  tags:
    - security
    - infrastructure
    - cloudflare
    - slack
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: update-rate-limit
          description: "Given a Cloudflare zone ID, rule ID, and new threshold, update the rate limit rule and notify security Slack."
          inputParameters:
            - name: zone_id
              in: body
              type: string
              description: "Cloudflare zone ID."
            - name: rule_id
              in: body
              type: string
              description: "Rate limiting rule ID."
            - name: threshold
              in: body
              type: integer
              description: "New requests-per-second threshold."
          steps:
            - name: update-rule
              type: call
              call: cloudflare.update-rate-limit
              with:
                zone_id: "{{zone_id}}"
                rule_id: "{{rule_id}}"
                threshold: "{{threshold}}"
            - name: notify-security
              type: call
              call: slack.post-message
              with:
                channel: "security-ops"
                text: "Cloudflare rate limit updated: zone {{zone_id}}, rule {{rule_id}}, new threshold: {{threshold}} rps"
  consumes:
    - type: http
      namespace: cloudflare
      baseUri: "https://api.cloudflare.com/client/v4"
      authentication:
        type: bearer
        token: "$secrets.cloudflare_token"
      resources:
        - name: rate-limits
          path: "/zones/{{zone_id}}/rate_limits/{{rule_id}}"
          inputParameters:
            - name: zone_id
              in: path
            - name: rule_id
              in: path
          operations:
            - name: update-rate-limit
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Searches Confluence for a runbook by title keyword and returns the page URL and last updated date.

naftiko: "0.5"
info:
  label: "Confluence Runbook Lookup"
  description: "Searches Confluence for a runbook by title keyword and returns the page URL and last updated date."
  tags:
    - engineering
    - documentation
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: docs-ops
      port: 8080
      tools:
        - name: find-runbook
          description: "Given a search keyword, find matching runbook pages in Confluence and return titles and URLs."
          inputParameters:
            - name: keyword
              in: body
              type: string
              description: "Search keyword for runbook title."
          call: confluence.search-content
          with:
            cql: "type=page AND title~'{{keyword}}' AND space=RUNBOOKS"
          outputParameters:
            - name: results
              type: array
              mapping: "$.results[*]"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://deliveroo.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_token"
      resources:
        - name: search
          path: "/search"
          operations:
            - name: search-content
              method: GET

Checks Kafka consumer group lag via Datadog and, if above threshold, creates a PagerDuty alert and notifies Slack.

naftiko: "0.5"
info:
  label: "Confluent Kafka Consumer Lag Alert"
  description: "Checks Kafka consumer group lag via Datadog and, if above threshold, creates a PagerDuty alert and notifies Slack."
  tags:
    - engineering
    - messaging
    - datadog
    - pagerduty
    - slack
capability:
  exposes:
    - type: mcp
      namespace: platform-ops
      port: 8080
      tools:
        - name: check-consumer-lag
          description: "Given a Kafka consumer group and lag threshold, check current lag in Datadog. If exceeded, trigger PagerDuty and Slack alerts."
          inputParameters:
            - name: consumer_group
              in: body
              type: string
              description: "Kafka consumer group name."
            - name: lag_threshold
              in: body
              type: integer
              description: "Maximum acceptable consumer lag."
          steps:
            - name: query-lag
              type: call
              call: datadog.query-timeseries
              with:
                query: "avg:kafka.consumer.lag{consumer_group:{{consumer_group}}}"
            - name: alert-pagerduty
              type: call
              call: pagerduty.create-event
              with:
                routing_key: "$secrets.pagerduty_routing_key"
                summary: "Kafka consumer lag for {{consumer_group}} exceeds {{lag_threshold}}"
                severity: "error"
            - name: notify-slack
              type: call
              call: slack.post-message
              with:
                channel: "platform-alerts"
                text: "Kafka consumer lag alert: {{consumer_group}} lag exceeded {{lag_threshold}}"
  consumes:
    - 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: query
          path: "/query"
          operations:
            - name: query-timeseries
              method: GET
    - type: http
      namespace: pagerduty
      baseUri: "https://events.pagerduty.com/v2"
      authentication:
        type: none
      resources:
        - name: events
          path: "/enqueue"
          operations:
            - name: create-event
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a GitHub Actions pipeline fails on the main branch, creates a Datadog deployment marker, opens a Jira bug, and alerts the mobile engineering Slack channel.

naftiko: "0.5"
info:
  label: "Consumer App Deployment Pipeline Failure Handler"
  description: "When a GitHub Actions pipeline fails on the main branch, creates a Datadog deployment marker, opens a Jira bug, and alerts the mobile engineering Slack channel."
  tags:
    - devops
    - cicd
    - github
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: mobile-devops
      port: 8080
      tools:
        - name: handle-app-pipeline-failure
          description: "Given a GitHub Actions run failure on the consumer app repo, annotate Datadog, create a Jira bug, and alert the mobile engineering Slack channel."
          inputParameters:
            - name: run_id
              in: body
              type: string
              description: "GitHub Actions workflow run ID that failed."
            - name: commit_sha
              in: body
              type: string
              description: "Git commit SHA that triggered the failing run."
            - name: branch
              in: body
              type: string
              description: "Git branch name where the failure occurred."
            - name: workflow_name
              in: body
              type: string
              description: "Name of the failed GitHub Actions workflow."
          steps:
            - name: create-dd-event
              type: call
              call: datadog.create-event
              with:
                title: "CI failure: {{workflow_name}} on {{branch}}"
                text: "Run {{run_id}} failed at commit {{commit_sha}}"
                alert_type: error
                tags: "env:ci,repo:consumer-app"
            - name: create-bug
              type: call
              call: jira.create-issue
              with:
                project_key: MOB
                issuetype: Bug
                summary: "[CI Failure] {{workflow_name}} — {{branch}} — {{commit_sha}}"
                description: "GitHub run: {{run_id}}\nBranch: {{branch}}\nCommit: {{commit_sha}}\nDatadog event: {{create-dd-event.id}}"
            - name: alert-channel
              type: call
              call: slack.post-message
              with:
                channel: mobile-engineering
                text: "Pipeline failure: {{workflow_name}} on {{branch}} | Commit: {{commit_sha}} | Jira: {{create-bug.key}}"
  consumes:
    - 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: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Zendesk ticket exceeds SLA thresholds, escalates to a Salesforce case, creates a PagerDuty alert for the support manager, and notifies the support Slack channel.

naftiko: "0.5"
info:
  label: "Customer Support Ticket Escalation"
  description: "When a Zendesk ticket exceeds SLA thresholds, escalates to a Salesforce case, creates a PagerDuty alert for the support manager, and notifies the support Slack channel."
  tags:
    - customer-support
    - escalation
    - zendesk
    - salesforce
    - pagerduty
    - slack
capability:
  exposes:
    - type: mcp
      namespace: support-ops
      port: 8080
      tools:
        - name: escalate-support-ticket
          description: "Given a Zendesk ticket ID that has breached SLA, create a Salesforce case, page the support manager via PagerDuty, and post to the support Slack channel."
          inputParameters:
            - name: zendesk_ticket_id
              in: body
              type: string
              description: "The Zendesk ticket ID that has breached its SLA."
            - name: sla_breach_minutes
              in: body
              type: integer
              description: "Number of minutes the ticket has exceeded the SLA target."
            - name: customer_email
              in: body
              type: string
              description: "Customer email address associated with the ticket."
          steps:
            - name: get-ticket
              type: call
              call: zendesk.get-ticket
              with:
                ticket_id: "{{zendesk_ticket_id}}"
            - name: create-case
              type: call
              call: salesforce.create-case
              with:
                subject: "SLA breach: Zendesk ticket {{zendesk_ticket_id}}"
                description: "SLA breached by {{sla_breach_minutes}} minutes. Customer: {{customer_email}}\nOriginal subject: {{get-ticket.subject}}"
                priority: High
                origin: Zendesk
            - name: page-manager
              type: call
              call: pagerduty.create-incident
              with:
                title: "Support SLA breach — ticket {{zendesk_ticket_id}} — {{sla_breach_minutes}}min over"
                urgency: high
                service_id: "$secrets.pagerduty_support_service_id"
            - name: notify-support
              type: call
              call: slack.post-message
              with:
                channel: customer-support
                text: "SLA breach: Ticket {{zendesk_ticket_id}} is {{sla_breach_minutes}}min overdue | Customer: {{customer_email}} | SF Case: {{create-case.case_number}}"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: tickets
          path: "/tickets/{{ticket_id}}"
          inputParameters:
            - name: ticket_id
              in: path
          operations:
            - name: get-ticket
              method: GET
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.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
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: Authorization
        value: "$secrets.pagerduty_api_key"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Datadog APM for p99 latency threshold breaches on the order API service and creates a PagerDuty incident when thresholds are exceeded.

naftiko: "0.5"
info:
  label: "Datadog APM Latency Threshold Alert"
  description: "Monitors Datadog APM for p99 latency threshold breaches on the order API service and creates a PagerDuty incident when thresholds are exceeded."
  tags:
    - observability
    - monitoring
    - datadog
    - pagerduty
    - operations
capability:
  exposes:
    - type: mcp
      namespace: apm-monitoring
      port: 8080
      tools:
        - name: handle-latency-breach
          description: "Given a Datadog monitor alert for p99 latency breach on a service endpoint, create a PagerDuty incident and notify the SRE Slack channel."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "Name of the service with the latency breach (e.g. order-api)."
            - name: p99_latency_ms
              in: body
              type: number
              description: "Measured p99 latency in milliseconds."
            - name: threshold_ms
              in: body
              type: number
              description: "Configured latency threshold in milliseconds."
            - name: monitor_id
              in: body
              type: string
              description: "Datadog monitor ID that triggered the alert."
          steps:
            - name: create-pd-incident
              type: call
              call: pagerduty.create-incident
              with:
                title: "Latency breach: {{service_name}} p99={{p99_latency_ms}}ms (threshold: {{threshold_ms}}ms)"
                urgency: high
                service_id: "$secrets.pagerduty_sre_service_id"
            - name: notify-sre
              type: call
              call: slack.post-message
              with:
                channel: sre-alerts
                text: "Latency breach: {{service_name}} p99={{p99_latency_ms}}ms vs threshold {{threshold_ms}}ms | Monitor: {{monitor_id}} | PD: {{create-pd-incident.html_url}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: Authorization
        value: "$secrets.pagerduty_api_key"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries a Datadog custom metric time series and returns the latest data points for operational dashboards.

naftiko: "0.5"
info:
  label: "Datadog Custom Metric Query"
  description: "Queries a Datadog custom metric time series and returns the latest data points for operational dashboards."
  tags:
    - monitoring
    - observability
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: query-metric
          description: "Given a Datadog metric query string and time range, return the latest data points."
          inputParameters:
            - name: query
              in: body
              type: string
              description: "Datadog metric query (e.g., avg:system.cpu.user{service:orders})."
            - name: from_ts
              in: body
              type: integer
              description: "Start timestamp (epoch seconds)."
            - name: to_ts
              in: body
              type: integer
              description: "End timestamp (epoch seconds)."
          call: datadog.query-timeseries
          with:
            query: "{{query}}"
            from: "{{from_ts}}"
            to: "{{to_ts}}"
          outputParameters:
            - name: series
              type: array
              mapping: "$.series"
  consumes:
    - 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: query
          path: "/query"
          operations:
            - name: query-timeseries
              method: GET

Searches Datadog logs by query string and returns matching log entries for debugging.

naftiko: "0.5"
info:
  label: "Datadog Log Search"
  description: "Searches Datadog logs by query string and returns matching log entries for debugging."
  tags:
    - engineering
    - observability
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: search-logs
          description: "Given a Datadog log query and time range, return matching log entries."
          inputParameters:
            - name: query
              in: body
              type: string
              description: "Datadog log search query."
            - name: from_ts
              in: body
              type: string
              description: "Start time (ISO 8601)."
            - name: to_ts
              in: body
              type: string
              description: "End time (ISO 8601)."
          call: datadog.search-logs
          with:
            query: "{{query}}"
            from: "{{from_ts}}"
            to: "{{to_ts}}"
          outputParameters:
            - name: logs
              type: array
              mapping: "$.data"
  consumes:
    - type: http
      namespace: datadog
      baseUri: "https://api.datadoghq.com/api/v2"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: logs
          path: "/logs/events/search"
          operations:
            - name: search-logs
              method: POST

Retrieves current monitor statuses for Deliveroo's core order processing services from Datadog and returns a structured health summary.

naftiko: "0.5"
info:
  label: "Datadog Service Health Check"
  description: "Retrieves current monitor statuses for Deliveroo's core order processing services from Datadog and returns a structured health summary."
  tags:
    - observability
    - monitoring
    - datadog
    - operations
capability:
  exposes:
    - type: mcp
      namespace: service-health
      port: 8080
      tools:
        - name: get-service-health
          description: "Given a Datadog monitor tag, retrieve all monitor statuses for the matching services and return a structured health summary. Use to check the live health of Deliveroo's core services."
          inputParameters:
            - name: monitor_tag
              in: body
              type: string
              description: "Datadog monitor tag to filter services (e.g. service:order-processor)."
          call: datadog.get-monitors
          with:
            monitor_tags: "{{monitor_tag}}"
          outputParameters:
            - name: monitors
              type: array
              mapping: "$.monitors"
  consumes:
    - 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: monitors
          path: "/monitor"
          inputParameters:
            - name: monitor_tags
              in: query
          operations:
            - name: get-monitors
              method: GET

Triggers a Datadog synthetic test by public ID and posts the result to the QA Slack channel.

naftiko: "0.5"
info:
  label: "Datadog Synthetic Test Trigger"
  description: "Triggers a Datadog synthetic test by public ID and posts the result to the QA Slack channel."
  tags:
    - monitoring
    - testing
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: qa-ops
      port: 8080
      tools:
        - name: trigger-synthetic-test
          description: "Given a Datadog synthetic test public ID, trigger a test run and post the result to Slack."
          inputParameters:
            - name: public_id
              in: body
              type: string
              description: "Datadog synthetic test public ID."
          steps:
            - name: trigger-test
              type: call
              call: datadog.trigger-ci-tests
              with:
                public_ids: "{{public_id}}"
            - name: post-result
              type: call
              call: slack.post-message
              with:
                channel: "qa-alerts"
                text: "Synthetic test {{public_id}} triggered. Batch ID: {{trigger-test.batch_id}}"
  consumes:
    - 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: synthetics
          path: "/synthetics/tests/trigger/ci"
          operations:
            - name: trigger-ci-tests
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for delivery time metrics by zone and refreshes the Tableau SLA dashboard used by operations leadership.

naftiko: "0.5"
info:
  label: "Delivery Time SLA Dashboard Refresh"
  description: "Queries Snowflake for delivery time metrics by zone and refreshes the Tableau SLA dashboard used by operations leadership."
  tags:
    - analytics
    - operations
    - snowflake
    - tableau
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: ops-reporting
      port: 8080
      tools:
        - name: refresh-delivery-sla-dashboard
          description: "Given a report date, query Snowflake for zone-level delivery time SLA metrics and trigger a Tableau workbook refresh."
          inputParameters:
            - name: report_date
              in: body
              type: string
              description: "ISO 8601 date for the SLA report period."
            - name: tableau_workbook_id
              in: body
              type: string
              description: "Tableau workbook ID to refresh after data is updated."
          steps:
            - name: get-sla-metrics
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT zone_id, AVG(delivery_minutes) as avg_delivery, COUNT(*) as order_count FROM deliveries WHERE delivery_date = '{{report_date}}' GROUP BY zone_id"
            - name: refresh-workbook
              type: call
              call: tableau.refresh-workbook
              with:
                workbook_id: "{{tableau_workbook_id}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: tableau
      baseUri: "https://10ax.online.tableau.com/api/2.8"
      authentication:
        type: apikey
        key: X-Tableau-Auth
        value: "$secrets.tableau_token"
        placement: header
      resources:
        - name: workbooks
          path: "/sites/{{site_id}}/workbooks/{{workbook_id}}/refresh"
          inputParameters:
            - name: site_id
              in: path
            - name: workbook_id
              in: path
          operations:
            - name: refresh-workbook
              method: POST

Searches the order index in Elasticsearch by customer email or order ID and returns matching order records.

naftiko: "0.5"
info:
  label: "Elasticsearch Order Search"
  description: "Searches the order index in Elasticsearch by customer email or order ID and returns matching order records."
  tags:
    - data
    - search
    - elasticsearch
capability:
  exposes:
    - type: mcp
      namespace: order-ops
      port: 8080
      tools:
        - name: search-orders
          description: "Given a customer email or order ID, search the Elasticsearch orders index and return matching records."
          inputParameters:
            - name: query
              in: body
              type: string
              description: "Customer email or order ID to search."
          call: elasticsearch.search
          with:
            index: "orders"
            q: "{{query}}"
          outputParameters:
            - name: hits
              type: array
              mapping: "$.hits.hits[*]._source"
            - name: total
              type: integer
              mapping: "$.hits.total.value"
  consumes:
    - type: http
      namespace: elasticsearch
      baseUri: "https://deliveroo-es.eu-west-1.es.amazonaws.com"
      authentication:
        type: aws-sigv4
        accessKeyId: "$secrets.aws_access_key"
        secretAccessKey: "$secrets.aws_secret_key"
      resources:
        - name: search
          path: "/orders/_search"
          operations:
            - name: search
              method: POST

When a Figma file is marked ready for development, posts the handoff link to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "Figma Design Handoff Notification"
  description: "When a Figma file is marked ready for development, posts the handoff link to the engineering Slack channel."
  tags:
    - design
    - collaboration
    - figma
    - slack
capability:
  exposes:
    - type: mcp
      namespace: design-ops
      port: 8080
      tools:
        - name: notify-handoff
          description: "Given a Figma file key, fetch file metadata and post a handoff notification to the engineering Slack channel."
          inputParameters:
            - name: file_key
              in: body
              type: string
              description: "Figma file key."
            - name: slack_channel
              in: body
              type: string
              description: "Engineering Slack channel."
          steps:
            - name: get-file
              type: call
              call: figma.get-file
              with:
                file_key: "{{file_key}}"
            - name: notify-eng
              type: call
              call: slack.post-message
              with:
                channel: "{{slack_channel}}"
                text: "Design handoff ready: {{get-file.name}} — https://www.figma.com/file/{{file_key}}"
  consumes:
    - type: http
      namespace: figma
      baseUri: "https://api.figma.com/v1"
      authentication:
        type: bearer
        token: "$secrets.figma_token"
      resources:
        - name: files
          path: "/files/{{file_key}}"
          inputParameters:
            - name: file_key
              in: path
          operations:
            - name: get-file
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a GitHub Actions deployment workflow completes, posts the deployment status and commit details to the releases Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Actions Deployment Notification"
  description: "When a GitHub Actions deployment workflow completes, posts the deployment status and commit details to the releases Slack channel."
  tags:
    - engineering
    - cicd
    - github-actions
    - slack
capability:
  exposes:
    - type: mcp
      namespace: deploy-ops
      port: 8080
      tools:
        - name: notify-deployment
          description: "Given a GitHub repo, workflow run ID, and environment, fetch the run details and post the deployment status to Slack."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "GitHub repository in org/repo format."
            - name: run_id
              in: body
              type: string
              description: "GitHub Actions workflow run ID."
            - name: environment
              in: body
              type: string
              description: "Deployment environment (staging, production)."
          steps:
            - name: get-run
              type: call
              call: github.get-workflow-run
              with:
                repo: "{{repo}}"
                run_id: "{{run_id}}"
            - name: post-notification
              type: call
              call: slack.post-message
              with:
                channel: "releases"
                text: "Deployment to {{environment}}: {{get-run.conclusion}} | {{repo}} @ {{get-run.head_sha}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: runs
          path: "/repos/{{repo}}/actions/runs/{{run_id}}"
          inputParameters:
            - name: repo
              in: path
            - name: run_id
              in: path
          operations:
            - name: get-workflow-run
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches open Dependabot alerts for a repository and posts a severity summary to the security Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Dependabot Alert Digest"
  description: "Fetches open Dependabot alerts for a repository and posts a severity summary to the security Slack channel."
  tags:
    - security
    - engineering
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: appsec
      port: 8080
      tools:
        - name: digest-dependabot-alerts
          description: "Given a GitHub repo, fetch open Dependabot alerts and post a grouped summary to Slack."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "GitHub repository in org/repo format."
          steps:
            - name: get-alerts
              type: call
              call: github.list-dependabot-alerts
              with:
                repo: "{{repo}}"
                state: "open"
            - name: post-digest
              type: call
              call: slack.post-message
              with:
                channel: "security-alerts"
                text: "Dependabot digest for {{repo}}: {{get-alerts.total}} open alerts"
  consumes:
    - type: http
      namespace: github
      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
          operations:
            - name: list-dependabot-alerts
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches open GitHub pull requests without reviews older than 24 hours and posts reminders to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "GitHub PR Review Reminder"
  description: "Fetches open GitHub pull requests without reviews older than 24 hours and posts reminders to the engineering Slack channel."
  tags:
    - engineering
    - code-review
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eng-ops
      port: 8080
      tools:
        - name: remind-stale-prs
          description: "Given a GitHub repository, find open PRs without reviews older than a threshold and post reminders to Slack."
          inputParameters:
            - name: repo
              in: body
              type: string
              description: "GitHub repository in org/repo format."
            - name: hours_threshold
              in: body
              type: integer
              description: "Hours since PR creation to flag."
          steps:
            - name: get-open-prs
              type: call
              call: github.list-pulls
              with:
                repo: "{{repo}}"
                state: "open"
            - name: post-reminder
              type: call
              call: slack.post-message
              with:
                channel: "engineering"
                text: "PR review reminder for {{repo}}: {{get-open-prs.stale_count}} PRs awaiting review for >{{hours_threshold}}h"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/{{repo}}/pulls"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: list-pulls
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a pull request is opened on a core service repository, triggers a Datadog security scan event and creates a Jira security review task if vulnerabilities are detected.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Security Scan"
  description: "When a pull request is opened on a core service repository, triggers a Datadog security scan event and creates a Jira security review task if vulnerabilities are detected."
  tags:
    - devops
    - security
    - github
    - datadog
    - jira
capability:
  exposes:
    - type: mcp
      namespace: security-devops
      port: 8080
      tools:
        - name: run-pr-security-scan
          description: "Given a GitHub pull request number and repository, trigger a Datadog security event and create a Jira security task if the scan detects high-severity vulnerabilities."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name (e.g. consumer-app)."
            - name: pr_number
              in: body
              type: integer
              description: "Pull request number in the repository."
            - name: vulnerability_count
              in: body
              type: integer
              description: "Number of high-severity vulnerabilities detected by the scanner."
            - name: commit_sha
              in: body
              type: string
              description: "Git commit SHA for the PR head."
          steps:
            - name: log-scan-event
              type: call
              call: datadog.create-event
              with:
                title: "Security scan: {{repo_name}} PR #{{pr_number}}"
                text: "{{vulnerability_count}} high-severity vulnerabilities detected at {{commit_sha}}"
                alert_type: warning
                tags: "repo:{{repo_name}},scan:pr"
            - name: create-security-task
              type: call
              call: jira.create-issue
              with:
                project_key: SEC
                issuetype: Task
                summary: "Security review: {{repo_name}} PR #{{pr_number}} — {{vulnerability_count}} vulnerabilities"
                description: "Commit: {{commit_sha}}\nVulnerabilities: {{vulnerability_count}}\nDatadog: {{log-scan-event.url}}"
  consumes:
    - 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: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

When a new GitHub release is published on a core service, posts a deployment announcement to the engineering Slack channel and creates a Datadog deployment marker.

naftiko: "0.5"
info:
  label: "GitHub Release Deployment Notification"
  description: "When a new GitHub release is published on a core service, posts a deployment announcement to the engineering Slack channel and creates a Datadog deployment marker."
  tags:
    - devops
    - deployment
    - github
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: release-management
      port: 8080
      tools:
        - name: announce-service-release
          description: "Given a GitHub release tag, repository name, and release notes URL, create a Datadog deployment marker and post a deployment announcement to the engineering Slack channel."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name for the released service."
            - name: release_tag
              in: body
              type: string
              description: "Git release tag (e.g. v2.4.1)."
            - name: release_notes_url
              in: body
              type: string
              description: "URL to the GitHub release notes page."
            - name: deployed_by
              in: body
              type: string
              description: "GitHub username of the person who triggered the release."
          steps:
            - name: create-dd-marker
              type: call
              call: datadog.create-deployment-marker
              with:
                entity_name: "{{repo_name}}"
                version: "{{release_tag}}"
                user: "{{deployed_by}}"
                description: "Release {{release_tag}} deployed from {{repo_name}}"
            - name: announce-release
              type: call
              call: slack.post-message
              with:
                channel: engineering-releases
                text: "Release deployed: {{repo_name}} {{release_tag}} by @{{deployed_by}} | Notes: {{release_notes_url}} | Datadog: {{create-dd-marker.url}}"
  consumes:
    - 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: deployments
          path: "/deployments"
          operations:
            - name: create-deployment-marker
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Audits GitHub repositories in the Deliveroo org for branch protection policy compliance and opens Jira tasks for any repositories that are non-compliant.

naftiko: "0.5"
info:
  label: "GitHub Repository Security Policy Enforcement"
  description: "Audits GitHub repositories in the Deliveroo org for branch protection policy compliance and opens Jira tasks for any repositories that are non-compliant."
  tags:
    - security
    - devops
    - github
    - jira
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: repo-compliance
      port: 8080
      tools:
        - name: audit-repo-branch-protection
          description: "Given a GitHub repository name, check its default branch protection rules and open a Jira security task if required protections are missing."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "GitHub repository name to audit for branch protection compliance."
          steps:
            - name: get-branch-protection
              type: call
              call: github.get-branch-protection
              with:
                owner: deliveroo
                repo: "{{repo_name}}"
                branch: main
            - name: create-compliance-task
              type: call
              call: jira.create-issue
              with:
                project_key: SEC
                issuetype: Task
                summary: "Branch protection missing: {{repo_name}}"
                description: "Repository {{repo_name}} is missing required branch protection on main. Enforce: required reviews, status checks, and signed commits."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: branch-protection
          path: "/repos/{{owner}}/{{repo}}/branches/{{branch}}/protection"
          inputParameters:
            - name: owner
              in: path
            - name: repo
              in: path
            - name: branch
              in: path
          operations:
            - name: get-branch-protection
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Executes a SQL query against Google BigQuery and returns the result for analytics lookups.

naftiko: "0.5"
info:
  label: "Google BigQuery Analytics Query"
  description: "Executes a SQL query against Google BigQuery and returns the result for analytics lookups."
  tags:
    - data
    - analytics
    - google-cloud-platform
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: run-bigquery
          description: "Given a SQL query, execute it against BigQuery and return results."
          inputParameters:
            - name: sql
              in: body
              type: string
              description: "BigQuery SQL query."
            - name: project_id
              in: body
              type: string
              description: "GCP project ID."
          call: bigquery.query
          with:
            query: "{{sql}}"
            project_id: "{{project_id}}"
          outputParameters:
            - name: rows
              type: array
              mapping: "$.rows"
            - name: total_rows
              type: string
              mapping: "$.totalRows"
  consumes:
    - type: http
      namespace: bigquery
      baseUri: "https://bigquery.googleapis.com/bigquery/v2"
      authentication:
        type: bearer
        token: "$secrets.gcp_token"
      resources:
        - name: queries
          path: "/projects/{{project_id}}/queries"
          inputParameters:
            - name: project_id
              in: path
          operations:
            - name: query
              method: POST

Geocodes a delivery address using Google Maps API, returning latitude, longitude, and formatted address.

naftiko: "0.5"
info:
  label: "Google Maps Geocoding Lookup"
  description: "Geocodes a delivery address using Google Maps API, returning latitude, longitude, and formatted address."
  tags:
    - logistics
    - geolocation
    - google-maps
capability:
  exposes:
    - type: mcp
      namespace: logistics-ops
      port: 8080
      tools:
        - name: geocode-address
          description: "Given an address string, return the geocoded latitude, longitude, and formatted address from Google Maps."
          inputParameters:
            - name: address
              in: body
              type: string
              description: "Delivery address to geocode."
          call: gmaps.geocode
          with:
            address: "{{address}}"
          outputParameters:
            - name: latitude
              type: number
              mapping: "$.results[0].geometry.location.lat"
            - name: longitude
              type: number
              mapping: "$.results[0].geometry.location.lng"
            - name: formatted_address
              type: string
              mapping: "$.results[0].formatted_address"
  consumes:
    - type: http
      namespace: gmaps
      baseUri: "https://maps.googleapis.com/maps/api"
      authentication:
        type: apikey
        key: "key"
        value: "$secrets.google_maps_api_key"
        placement: query
      resources:
        - name: geocode
          path: "/geocode/json"
          operations:
            - name: geocode
              method: GET

Updates a Google Sheets KPI tracker with the latest weekly metrics from Snowflake and notifies the ops team via Slack.

naftiko: "0.5"
info:
  label: "Google Sheets Weekly KPI Update"
  description: "Updates a Google Sheets KPI tracker with the latest weekly metrics from Snowflake and notifies the ops team via Slack."
  tags:
    - analytics
    - reporting
    - google-sheets
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ops-analytics
      port: 8080
      tools:
        - name: update-kpi-sheet
          description: "Fetch weekly KPIs from Snowflake, update the Google Sheets tracker, and notify the ops Slack channel."
          inputParameters:
            - name: spreadsheet_id
              in: body
              type: string
              description: "Google Sheets spreadsheet ID."
            - name: sheet_name
              in: body
              type: string
              description: "Sheet tab name."
          steps:
            - name: fetch-kpis
              type: call
              call: snowflake.execute-statement
              with:
                statement: "SELECT metric_name, value FROM weekly_kpis WHERE week = CURRENT_DATE - 7"
            - name: update-sheet
              type: call
              call: gsheets.append-values
              with:
                spreadsheet_id: "{{spreadsheet_id}}"
                range: "{{sheet_name}}!A:B"
                values: "{{fetch-kpis.data}}"
            - name: notify-ops
              type: call
              call: slack.post-message
              with:
                channel: "ops-analytics"
                text: "Weekly KPI sheet updated: {{sheet_name}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST
    - type: http
      namespace: gsheets
      baseUri: "https://sheets.googleapis.com/v4"
      authentication:
        type: bearer
        token: "$secrets.google_sheets_token"
      resources:
        - name: values
          path: "/spreadsheets/{{spreadsheet_id}}/values/{{range}}:append"
          inputParameters:
            - name: spreadsheet_id
              in: path
            - name: range
              in: path
          operations:
            - name: append-values
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates an annotation on a Grafana dashboard to mark a deployment or incident event for operational context.

naftiko: "0.5"
info:
  label: "Grafana Dashboard Annotation"
  description: "Creates an annotation on a Grafana dashboard to mark a deployment or incident event for operational context."
  tags:
    - monitoring
    - observability
    - grafana
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: create-annotation
          description: "Given a Grafana dashboard ID and event description, create a time-stamped annotation."
          inputParameters:
            - name: dashboard_id
              in: body
              type: integer
              description: "Grafana dashboard ID."
            - name: text
              in: body
              type: string
              description: "Annotation text."
            - name: tags
              in: body
              type: string
              description: "Comma-separated tags."
          call: grafana.create-annotation
          with:
            dashboardId: "{{dashboard_id}}"
            text: "{{text}}"
            tags: "{{tags}}"
          outputParameters:
            - name: annotation_id
              type: integer
              mapping: "$.id"
  consumes:
    - type: http
      namespace: grafana
      baseUri: "https://grafana.deliveroo.net/api"
      authentication:
        type: bearer
        token: "$secrets.grafana_token"
      resources:
        - name: annotations
          path: "/annotations"
          operations:
            - name: create-annotation
              method: POST

Pulls current headcount data from Workday and writes a department-level snapshot to Snowflake for workforce planning and finance reporting.

naftiko: "0.5"
info:
  label: "Headcount and Workforce Snapshot"
  description: "Pulls current headcount data from Workday and writes a department-level snapshot to Snowflake for workforce planning and finance reporting."
  tags:
    - hr
    - workforce-planning
    - workday
    - snowflake
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: workforce-reporting
      port: 8080
      tools:
        - name: snapshot-headcount
          description: "Retrieve active headcount from Workday across all departments and write the snapshot to Snowflake for workforce planning dashboards."
          inputParameters:
            - name: snapshot_date
              in: body
              type: string
              description: "ISO 8601 date for the headcount snapshot."
          steps:
            - name: get-workers
              type: call
              call: workday.list-workers
              with:
                effective_date: "{{snapshot_date}}"
                employment_status: active
            - name: write-snapshot
              type: call
              call: snowflake.execute-query
              with:
                statement: "INSERT INTO headcount_snapshots SELECT '{{snapshot_date}}' as snapshot_date, department, COUNT(*) as headcount FROM (VALUES {{get-workers.data}}) GROUP BY department"
  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"
          inputParameters:
            - name: effective_date
              in: query
            - name: employment_status
              in: query
          operations:
            - name: list-workers
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST

Retrieves recent customer conversations from Intercom by customer email for support context.

naftiko: "0.5"
info:
  label: "Intercom Customer Conversation Lookup"
  description: "Retrieves recent customer conversations from Intercom by customer email for support context."
  tags:
    - support
    - customer-engagement
    - intercom
capability:
  exposes:
    - type: mcp
      namespace: support-ops
      port: 8080
      tools:
        - name: get-conversations
          description: "Given a customer email, return recent Intercom conversations with message previews."
          inputParameters:
            - name: email
              in: body
              type: string
              description: "Customer email."
          call: intercom.search-conversations
          with:
            email: "{{email}}"
          outputParameters:
            - name: conversations
              type: array
              mapping: "$.conversations"
  consumes:
    - type: http
      namespace: intercom
      baseUri: "https://api.intercom.io"
      authentication:
        type: bearer
        token: "$secrets.intercom_token"
      resources:
        - name: conversations
          path: "/conversations/search"
          operations:
            - name: search-conversations
              method: POST

Produces a weekly backlog digest by querying Jira for unestimated and stale issues across engineering projects and posting the summary to the relevant Slack channel.

naftiko: "0.5"
info:
  label: "Jira Backlog Grooming Digest"
  description: "Produces a weekly backlog digest by querying Jira for unestimated and stale issues across engineering projects and posting the summary to the relevant Slack channel."
  tags:
    - devops
    - engineering
    - jira
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: backlog-reporting
      port: 8080
      tools:
        - name: digest-backlog-health
          description: "Given a Jira project key, retrieve unestimated and stale issues older than 14 days, then post a digest summary to the engineering Slack channel for grooming prioritisation."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key to analyse (e.g. ENG, MOB, DATA)."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel to post the backlog digest to."
          steps:
            - name: search-issues
              type: call
              call: jira.search-issues
              with:
                jql: "project = {{project_key}} AND status = Backlog AND (story_points is EMPTY OR updated <= -14d) ORDER BY created ASC"
                maxResults: 50
            - name: post-digest
              type: call
              call: slack.post-message
              with:
                channel: "{{slack_channel}}"
                text: "Backlog health — {{project_key}}: {{search-issues.total}} issues need grooming (unestimated or stale >14d). Review: https://deliveroo.atlassian.net/jira/software/projects/{{project_key}}/boards"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/search"
          inputParameters:
            - name: jql
              in: query
            - name: maxResults
              in: query
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a customer-reported bug lands in Jira, enriches it with Zendesk ticket data and routes to the appropriate engineering team via Slack.

naftiko: "0.5"
info:
  label: "Jira Customer Bug Triage"
  description: "When a customer-reported bug lands in Jira, enriches it with Zendesk ticket data and routes to the appropriate engineering team via Slack."
  tags:
    - engineering
    - support
    - jira
    - zendesk
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eng-triage
      port: 8080
      tools:
        - name: triage-customer-bug
          description: "Given a Jira issue key and linked Zendesk ticket ID, enrich the Jira issue with customer context and notify the owning team Slack channel."
          inputParameters:
            - name: issue_key
              in: body
              type: string
              description: "Jira issue key."
            - name: zendesk_ticket_id
              in: body
              type: string
              description: "Linked Zendesk ticket ID."
          steps:
            - name: get-zendesk-ticket
              type: call
              call: zendesk.get-ticket
              with:
                ticket_id: "{{zendesk_ticket_id}}"
            - name: update-jira
              type: call
              call: jira.update-issue
              with:
                issue_key: "{{issue_key}}"
                description: "Customer context: {{get-zendesk-ticket.description}}"
            - name: notify-team
              type: call
              call: slack.post-message
              with:
                channel: "eng-triage"
                text: "Customer bug triaged: {{issue_key}} | Zendesk: {{zendesk_ticket_id}} | Priority: {{get-zendesk-ticket.priority}}"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: tickets
          path: "/tickets/{{ticket_id}}.json"
          inputParameters:
            - name: ticket_id
              in: path
          operations:
            - name: get-ticket
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue/{{issue_key}}"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: update-issue
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches completed Jira issues for a version and publishes release notes as a Confluence page.

naftiko: "0.5"
info:
  label: "Jira Release Notes to Confluence"
  description: "Fetches completed Jira issues for a version and publishes release notes as a Confluence page."
  tags:
    - engineering
    - release-management
    - jira
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: release-ops
      port: 8080
      tools:
        - name: publish-release-notes
          description: "Given a Jira project and version, fetch resolved issues and create a Confluence release notes page."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "Jira project key."
            - name: version
              in: body
              type: string
              description: "Fix version name."
          steps:
            - name: get-issues
              type: call
              call: jira.search-issues
              with:
                jql: "project={{project_key}} AND fixVersion='{{version}}' AND status=Done"
            - name: create-page
              type: call
              call: confluence.create-content
              with:
                space_key: "RELEASES"
                title: "Release Notes — {{version}}"
                body: "{{get-issues.formatted}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_token"
      resources:
        - name: search
          path: "/search"
          operations:
            - name: search-issues
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://deliveroo.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_token"
      resources:
        - name: content
          path: "/content"
          operations:
            - name: create-content
              method: POST

Pulls completed sprint data from Jira and generates a velocity report stored in Snowflake for engineering leadership review.

naftiko: "0.5"
info:
  label: "Jira Sprint Velocity Report"
  description: "Pulls completed sprint data from Jira and generates a velocity report stored in Snowflake for engineering leadership review."
  tags:
    - devops
    - reporting
    - jira
    - snowflake
    - engineering
capability:
  exposes:
    - type: mcp
      namespace: eng-reporting
      port: 8080
      tools:
        - name: publish-sprint-velocity
          description: "Given a Jira board ID and sprint ID, retrieve completed story points and issue counts, then write the velocity summary to Snowflake for engineering analytics."
          inputParameters:
            - name: board_id
              in: body
              type: string
              description: "Jira board ID for the engineering squad."
            - name: sprint_id
              in: body
              type: string
              description: "Jira sprint ID to report on."
          steps:
            - name: get-sprint-report
              type: call
              call: jira.get-sprint
              with:
                board_id: "{{board_id}}"
                sprint_id: "{{sprint_id}}"
            - name: store-velocity
              type: call
              call: snowflake.execute-query
              with:
                statement: "INSERT INTO sprint_velocity (board_id, sprint_id, completed_points, issue_count, snapshot_date) VALUES ('{{board_id}}', '{{sprint_id}}', {{get-sprint-report.completed_points}}, {{get-sprint-report.issue_count}}, CURRENT_DATE)"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: sprints
          path: "/board/{{board_id}}/sprint/{{sprint_id}}"
          inputParameters:
            - name: board_id
              in: path
            - name: sprint_id
              in: path
          operations:
            - name: get-sprint
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST

Looks up any existing Jira tickets associated with a specific order ID for use in support and operations investigations.

naftiko: "0.5"
info:
  label: "Jira Ticket Lookup by Order ID"
  description: "Looks up any existing Jira tickets associated with a specific order ID for use in support and operations investigations."
  tags:
    - operations
    - support
    - jira
    - lookup
capability:
  exposes:
    - type: mcp
      namespace: order-ops
      port: 8080
      tools:
        - name: get-order-tickets
          description: "Given a Deliveroo order ID, search Jira for all issues referencing that order and return the list of matching tickets. Use during support escalations and incident investigations."
          inputParameters:
            - name: order_id
              in: body
              type: string
              description: "The Deliveroo order ID to search for in Jira tickets."
          call: jira.search-issues
          with:
            jql: "text ~ \"{{order_id}}\" ORDER BY created DESC"
            maxResults: 20
          outputParameters:
            - name: issues
              type: array
              mapping: "$.issues"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/search"
          inputParameters:
            - name: jql
              in: query
            - name: maxResults
              in: query
          operations:
            - name: search-issues
              method: GET

Triggers a Kubernetes deployment rollback via the GitHub Actions workflow and notifies the platform team via Slack.

naftiko: "0.5"
info:
  label: "Kubernetes Deployment Rollback"
  description: "Triggers a Kubernetes deployment rollback via the GitHub Actions workflow and notifies the platform team via Slack."
  tags:
    - infrastructure
    - containers
    - kubernetes
    - github-actions
    - slack
capability:
  exposes:
    - type: mcp
      namespace: platform-ops
      port: 8080
      tools:
        - name: rollback-deployment
          description: "Given a service name and target revision, trigger a rollback via GitHub Actions and notify the platform Slack channel."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "Service name to roll back."
            - name: target_revision
              in: body
              type: string
              description: "Git SHA or tag to roll back to."
          steps:
            - name: trigger-rollback
              type: call
              call: github.create-workflow-dispatch
              with:
                repo: "deliveroo/{{service_name}}"
                workflow_id: "rollback.yml"
                ref: "main"
                inputs:
                  revision: "{{target_revision}}"
            - name: notify-platform
              type: call
              call: slack.post-message
              with:
                channel: "platform-ops"
                text: "Rollback triggered for {{service_name}} to revision {{target_revision}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: workflow-dispatches
          path: "/repos/{{repo}}/actions/workflows/{{workflow_id}}/dispatches"
          inputParameters:
            - name: repo
              in: path
            - name: workflow_id
              in: path
          operations:
            - name: create-workflow-dispatch
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Toggles a LaunchDarkly feature flag for a given environment and notifies the engineering Slack channel.

naftiko: "0.5"
info:
  label: "LaunchDarkly Feature Flag Toggle"
  description: "Toggles a LaunchDarkly feature flag for a given environment and notifies the engineering Slack channel."
  tags:
    - engineering
    - feature-management
    - launchdarkly
    - slack
capability:
  exposes:
    - type: mcp
      namespace: release-ops
      port: 8080
      tools:
        - name: toggle-feature-flag
          description: "Given a LaunchDarkly feature flag key and environment, toggle the flag and notify engineering via Slack."
          inputParameters:
            - name: flag_key
              in: body
              type: string
              description: "Feature flag key."
            - name: environment
              in: body
              type: string
              description: "Target environment (staging, production)."
            - name: enabled
              in: body
              type: boolean
              description: "Whether to enable or disable the flag."
          steps:
            - name: update-flag
              type: call
              call: launchdarkly.patch-flag
              with:
                flag_key: "{{flag_key}}"
                environment: "{{environment}}"
                on: "{{enabled}}"
            - name: notify-eng
              type: call
              call: slack.post-message
              with:
                channel: "engineering"
                text: "Feature flag {{flag_key}} set to {{enabled}} in {{environment}}"
  consumes:
    - type: http
      namespace: launchdarkly
      baseUri: "https://app.launchdarkly.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.launchdarkly_token"
      resources:
        - name: flags
          path: "/flags/default/{{flag_key}}"
          inputParameters:
            - name: flag_key
              in: path
          operations:
            - name: patch-flag
              method: PATCH
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates a new issue in Linear and posts the issue link to the team Slack channel.

naftiko: "0.5"
info:
  label: "Linear Issue Creation"
  description: "Creates a new issue in Linear and posts the issue link to the team Slack channel."
  tags:
    - engineering
    - project-management
    - linear
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eng-ops
      port: 8080
      tools:
        - name: create-linear-issue
          description: "Given a team ID, title, and description, create a Linear issue and post the link to Slack."
          inputParameters:
            - name: team_id
              in: body
              type: string
              description: "Linear team ID."
            - name: title
              in: body
              type: string
              description: "Issue title."
            - name: description
              in: body
              type: string
              description: "Issue description."
          steps:
            - name: create-issue
              type: call
              call: linear.create-issue
              with:
                teamId: "{{team_id}}"
                title: "{{title}}"
                description: "{{description}}"
            - name: notify-team
              type: call
              call: slack.post-message
              with:
                channel: "engineering"
                text: "New Linear issue: {{title}} — {{create-issue.url}}"
  consumes:
    - type: http
      namespace: linear
      baseUri: "https://api.linear.app"
      authentication:
        type: bearer
        token: "$secrets.linear_token"
      resources:
        - name: graphql
          path: "/graphql"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves a retention analysis from Mixpanel for a given event and cohort, returning weekly retention percentages.

naftiko: "0.5"
info:
  label: "Mixpanel Retention Report"
  description: "Retrieves a retention analysis from Mixpanel for a given event and cohort, returning weekly retention percentages."
  tags:
    - analytics
    - product
    - mixpanel
capability:
  exposes:
    - type: mcp
      namespace: product-analytics
      port: 8080
      tools:
        - name: get-retention
          description: "Given a Mixpanel event name and date range, return weekly retention percentages."
          inputParameters:
            - name: event
              in: body
              type: string
              description: "Mixpanel event name for retention analysis."
            - name: from_date
              in: body
              type: string
              description: "Start date (YYYY-MM-DD)."
          call: mixpanel.get-retention
          with:
            event: "{{event}}"
            from_date: "{{from_date}}"
          outputParameters:
            - name: data
              type: object
              mapping: "$.data"
  consumes:
    - type: http
      namespace: mixpanel
      baseUri: "https://mixpanel.com/api/2.0"
      authentication:
        type: basic
        username: "$secrets.mixpanel_api_secret"
        password: ""
      resources:
        - name: retention
          path: "/retention"
          operations:
            - name: get-retention
              method: GET

Queries MongoDB Atlas for a customer's order history by customer ID, returning recent orders with statuses.

naftiko: "0.5"
info:
  label: "MongoDB Order History Query"
  description: "Queries MongoDB Atlas for a customer's order history by customer ID, returning recent orders with statuses."
  tags:
    - data
    - orders
    - mongodb
capability:
  exposes:
    - type: mcp
      namespace: order-ops
      port: 8080
      tools:
        - name: get-order-history
          description: "Given a customer ID, query MongoDB for the most recent orders with statuses and totals."
          inputParameters:
            - name: customer_id
              in: body
              type: string
              description: "Customer ID."
            - name: limit
              in: body
              type: integer
              description: "Number of recent orders to return."
          call: mongodb.find-documents
          with:
            collection: "orders"
            filter:
              customer_id: "{{customer_id}}"
            limit: "{{limit}}"
          outputParameters:
            - name: orders
              type: array
              mapping: "$.documents"
  consumes:
    - type: http
      namespace: mongodb
      baseUri: "https://data.mongodb-api.com/app/data-deliveroo/endpoint/data/v1"
      authentication:
        type: bearer
        token: "$secrets.mongodb_api_key"
      resources:
        - name: find
          path: "/action/find"
          operations:
            - name: find-documents
              method: POST

When a new engineering hire is created in Workday, provisions GitHub access, creates a Jira onboarding ticket, and sends a Slack welcome message to the engineering team channel.

naftiko: "0.5"
info:
  label: "New Hire Engineering Onboarding"
  description: "When a new engineering hire is created in Workday, provisions GitHub access, creates a Jira onboarding ticket, and sends a Slack welcome message to the engineering team channel."
  tags:
    - hr
    - onboarding
    - workday
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eng-onboarding
      port: 8080
      tools:
        - name: onboard-engineer
          description: "Given a Workday employee ID and GitHub username, provision GitHub org membership, create a Jira onboarding ticket, and post a Slack welcome message."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "The Workday worker ID for the new engineering hire."
            - name: github_username
              in: body
              type: string
              description: "The new hire's GitHub username to add to the Deliveroo org."
            - name: team_slug
              in: body
              type: string
              description: "GitHub team slug for the new hire's engineering squad."
          steps:
            - name: get-employee
              type: call
              call: workday.get-worker
              with:
                worker_id: "{{workday_employee_id}}"
            - name: add-to-github
              type: call
              call: github.add-org-member
              with:
                org: deliveroo
                username: "{{github_username}}"
                role: member
            - name: add-to-team
              type: call
              call: github-teams.add-team-member
              with:
                org: deliveroo
                team_slug: "{{team_slug}}"
                username: "{{github_username}}"
            - name: create-ticket
              type: call
              call: jira.create-issue
              with:
                project_key: ENG
                issuetype: Task
                summary: "Engineer onboarding: {{get-employee.full_name}}"
                description: "New engineer {{get-employee.full_name}} joined {{get-employee.department}}. GitHub: {{github_username}}, Team: {{team_slug}}"
            - name: welcome-message
              type: call
              call: slack.post-message
              with:
                channel: engineering
                text: "Welcome to Deliveroo Engineering, {{get-employee.first_name}}! Jira ticket: {{create-ticket.key}} | GitHub: @{{github_username}}"
  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: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/deliveroo/memberships/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: add-org-member
              method: PUT
    - type: http
      namespace: github-teams
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: team-members
          path: "/orgs/deliveroo/teams/{{team_slug}}/memberships/{{username}}"
          inputParameters:
            - name: team_slug
              in: path
            - name: username
              in: path
          operations:
            - name: add-team-member
              method: PUT
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates a new meeting notes page in Notion with an agenda template and posts the link to the Slack channel.

naftiko: "0.5"
info:
  label: "Notion Meeting Notes Creation"
  description: "Creates a new meeting notes page in Notion with an agenda template and posts the link to the Slack channel."
  tags:
    - collaboration
    - documentation
    - notion
    - slack
capability:
  exposes:
    - type: mcp
      namespace: collab-ops
      port: 8080
      tools:
        - name: create-meeting-notes
          description: "Given a meeting title and Notion database ID, create a meeting notes page and share the link in Slack."
          inputParameters:
            - name: title
              in: body
              type: string
              description: "Meeting title."
            - name: database_id
              in: body
              type: string
              description: "Notion database ID."
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel to share the link."
          steps:
            - name: create-page
              type: call
              call: notion.create-page
              with:
                parent_database_id: "{{database_id}}"
                title: "{{title}}"
            - name: share-link
              type: call
              call: slack.post-message
              with:
                channel: "{{slack_channel}}"
                text: "Meeting notes created: {{title}} — {{create-page.url}}"
  consumes:
    - type: http
      namespace: notion
      baseUri: "https://api.notion.com/v1"
      authentication:
        type: bearer
        token: "$secrets.notion_token"
      resources:
        - name: pages
          path: "/pages"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates a new Okta user account with group assignments based on department and role, then notifies IT via Slack.

naftiko: "0.5"
info:
  label: "Okta User Provisioning"
  description: "Creates a new Okta user account with group assignments based on department and role, then notifies IT via Slack."
  tags:
    - identity
    - provisioning
    - okta
    - slack
capability:
  exposes:
    - type: mcp
      namespace: iam-ops
      port: 8080
      tools:
        - name: provision-okta-user
          description: "Given employee details, create an Okta user, assign to department groups, and notify the IT Slack channel."
          inputParameters:
            - name: email
              in: body
              type: string
              description: "Employee email address."
            - name: first_name
              in: body
              type: string
              description: "First name."
            - name: last_name
              in: body
              type: string
              description: "Last name."
            - name: department
              in: body
              type: string
              description: "Department name for group assignment."
          steps:
            - name: create-user
              type: call
              call: okta.create-user
              with:
                email: "{{email}}"
                firstName: "{{first_name}}"
                lastName: "{{last_name}}"
            - name: notify-it
              type: call
              call: slack.post-message
              with:
                channel: "it-provisioning"
                text: "Okta user created: {{email}} ({{department}}). User ID: {{create-user.id}}"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://deliveroo.okta.com/api/v1"
      authentication:
        type: bearer
        token: "$secrets.okta_api_token"
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Uses OpenAI to summarize a customer order issue from Zendesk ticket notes, then updates the Zendesk ticket with the AI summary.

naftiko: "0.5"
info:
  label: "OpenAI Order Issue Summarization"
  description: "Uses OpenAI to summarize a customer order issue from Zendesk ticket notes, then updates the Zendesk ticket with the AI summary."
  tags:
    - ai
    - support
    - openai
    - zendesk
capability:
  exposes:
    - type: mcp
      namespace: support-ai
      port: 8080
      tools:
        - name: summarize-order-issue
          description: "Given a Zendesk ticket ID, fetch the conversation, summarize via OpenAI, and update the ticket with the summary."
          inputParameters:
            - name: ticket_id
              in: body
              type: string
              description: "Zendesk ticket ID."
          steps:
            - name: get-ticket
              type: call
              call: zendesk.get-ticket
              with:
                ticket_id: "{{ticket_id}}"
            - name: summarize
              type: call
              call: openai.create-completion
              with:
                model: "gpt-4"
                prompt: "Summarize this customer order issue: {{get-ticket.description}}"
            - name: update-ticket
              type: call
              call: zendesk.update-ticket
              with:
                ticket_id: "{{ticket_id}}"
                internal_note: "AI Summary: {{summarize.text}}"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: tickets
          path: "/tickets/{{ticket_id}}.json"
          inputParameters:
            - name: ticket_id
              in: path
          operations:
            - name: get-ticket
              method: GET
            - name: update-ticket
              method: PUT
    - type: http
      namespace: openai
      baseUri: "https://api.openai.com/v1"
      authentication:
        type: bearer
        token: "$secrets.openai_api_key"
      resources:
        - name: completions
          path: "/chat/completions"
          operations:
            - name: create-completion
              method: POST

Acknowledges an OpsGenie alert and posts the acknowledgement details to the on-call Slack channel.

naftiko: "0.5"
info:
  label: "OpsGenie Alert Acknowledgement"
  description: "Acknowledges an OpsGenie alert and posts the acknowledgement details to the on-call Slack channel."
  tags:
    - incident-management
    - operations
    - opsgenie
    - slack
capability:
  exposes:
    - type: mcp
      namespace: incident-ops
      port: 8080
      tools:
        - name: acknowledge-alert
          description: "Given an OpsGenie alert ID and responder, acknowledge the alert and notify the on-call Slack channel."
          inputParameters:
            - name: alert_id
              in: body
              type: string
              description: "OpsGenie alert ID."
            - name: responder
              in: body
              type: string
              description: "Name of the acknowledging responder."
          steps:
            - name: ack-alert
              type: call
              call: opsgenie.acknowledge-alert
              with:
                alert_id: "{{alert_id}}"
                user: "{{responder}}"
            - name: notify-oncall
              type: call
              call: slack.post-message
              with:
                channel: "oncall-alerts"
                text: "Alert {{alert_id}} acknowledged by {{responder}}"
  consumes:
    - type: http
      namespace: opsgenie
      baseUri: "https://api.opsgenie.com/v2"
      authentication:
        type: bearer
        token: "$secrets.opsgenie_token"
      resources:
        - name: alerts
          path: "/alerts/{{alert_id}}/acknowledge"
          inputParameters:
            - name: alert_id
              in: path
          operations:
            - name: acknowledge-alert
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects elevated order failure rates, creates a PagerDuty incident, opens a Jira bug, and posts a Slack alert to the engineering on-call channel.

naftiko: "0.5"
info:
  label: "Order Fulfilment Incident Response"
  description: "When Datadog detects elevated order failure rates, creates a PagerDuty incident, opens a Jira bug, and posts a Slack alert to the engineering on-call channel."
  tags:
    - incident-response
    - operations
    - datadog
    - pagerduty
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: fulfilment-ops
      port: 8080
      tools:
        - name: handle-order-failure-incident
          description: "Given an elevated order failure alert, create a PagerDuty incident, open a Jira bug with full context, and notify the on-call Slack channel."
          inputParameters:
            - name: alert_id
              in: body
              type: string
              description: "Datadog monitor alert ID that triggered this incident."
            - name: failure_rate_pct
              in: body
              type: number
              description: "Current order failure rate as a percentage."
            - name: zone_id
              in: body
              type: string
              description: "Affected Deliveroo zone ID."
            - name: service_name
              in: body
              type: string
              description: "Name of the failing backend service."
          steps:
            - name: create-incident
              type: call
              call: pagerduty.create-incident
              with:
                title: "Order failure spike: {{service_name}} in zone {{zone_id}}"
                urgency: high
                service_id: "$secrets.pagerduty_order_service_id"
            - name: create-jira-bug
              type: call
              call: jira.create-issue
              with:
                project_key: ENG
                issuetype: Bug
                summary: "[Incident] Order failure rate {{failure_rate_pct}}% — {{service_name}} / zone {{zone_id}}"
                description: "Datadog alert: {{alert_id}}\nFailure rate: {{failure_rate_pct}}%\nZone: {{zone_id}}\nPagerDuty incident: {{create-incident.id}}"
            - name: notify-oncall
              type: call
              call: slack.post-message
              with:
                channel: engineering-oncall
                text: "Incident: Order failures at {{failure_rate_pct}}% in zone {{zone_id}} | Service: {{service_name}} | PD: {{create-incident.html_url}} | Jira: {{create-jira-bug.key}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: Authorization
        value: "$secrets.pagerduty_api_key"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves a PagerDuty incident by ID and returns the title, status, urgency, and assigned responders.

naftiko: "0.5"
info:
  label: "PagerDuty Incident Summary"
  description: "Retrieves a PagerDuty incident by ID and returns the title, status, urgency, and assigned responders."
  tags:
    - engineering
    - incident-management
    - pagerduty
capability:
  exposes:
    - type: mcp
      namespace: incident-ops
      port: 8080
      tools:
        - name: get-incident-summary
          description: "Given a PagerDuty incident ID, return the title, status, urgency, and assigned users."
          inputParameters:
            - name: incident_id
              in: body
              type: string
              description: "PagerDuty incident ID."
          call: pagerduty.get-incident
          with:
            incident_id: "{{incident_id}}"
          outputParameters:
            - name: title
              type: string
              mapping: "$.incident.title"
            - name: status
              type: string
              mapping: "$.incident.status"
            - name: urgency
              type: string
              mapping: "$.incident.urgency"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: bearer
        token: "$secrets.pagerduty_token"
      resources:
        - name: incidents
          path: "/incidents/{{incident_id}}"
          inputParameters:
            - name: incident_id
              in: path
          operations:
            - name: get-incident
              method: GET

Retrieves the current on-call engineer for a given PagerDuty schedule and returns their name and contact details for incident coordination.

naftiko: "0.5"
info:
  label: "PagerDuty On-Call Schedule Lookup"
  description: "Retrieves the current on-call engineer for a given PagerDuty schedule and returns their name and contact details for incident coordination."
  tags:
    - operations
    - incident-response
    - pagerduty
    - on-call
capability:
  exposes:
    - type: mcp
      namespace: oncall-lookup
      port: 8080
      tools:
        - name: get-current-oncall
          description: "Given a PagerDuty schedule ID, return the name and contact information of the currently on-call engineer. Use at the start of any incident response workflow."
          inputParameters:
            - name: schedule_id
              in: body
              type: string
              description: "PagerDuty schedule ID to query for the current on-call."
          call: pagerduty.get-oncall
          with:
            schedule_id: "{{schedule_id}}"
          outputParameters:
            - name: user_name
              type: string
              mapping: "$.oncalls[0].user.name"
            - name: user_email
              type: string
              mapping: "$.oncalls[0].user.email"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: Authorization
        value: "$secrets.pagerduty_api_key"
        placement: header
      resources:
        - name: oncalls
          path: "/oncalls"
          inputParameters:
            - name: schedule_id
              in: query
          operations:
            - name: get-oncall
              method: GET

Triggers a Postman collection run via the Postman API and returns pass/fail results.

naftiko: "0.5"
info:
  label: "Postman API Test Run"
  description: "Triggers a Postman collection run via the Postman API and returns pass/fail results."
  tags:
    - engineering
    - api-testing
    - postman
capability:
  exposes:
    - type: mcp
      namespace: api-ops
      port: 8080
      tools:
        - name: run-api-tests
          description: "Given a Postman collection ID and environment ID, trigger a collection run and return pass/fail counts."
          inputParameters:
            - name: collection_id
              in: body
              type: string
              description: "Postman collection ID."
            - name: environment_id
              in: body
              type: string
              description: "Postman environment ID."
          call: postman.run-collection
          with:
            collection: "{{collection_id}}"
            environment: "{{environment_id}}"
          outputParameters:
            - name: total
              type: integer
              mapping: "$.run.stats.assertions.total"
            - name: passed
              type: integer
              mapping: "$.run.stats.assertions.passed"
            - name: failed
              type: integer
              mapping: "$.run.stats.assertions.failed"
  consumes:
    - type: http
      namespace: postman
      baseUri: "https://api.getpostman.com"
      authentication:
        type: apikey
        key: "X-Api-Key"
        value: "$secrets.postman_api_key"
        placement: header
      resources:
        - name: runs
          path: "/collections/{{collection}}/runs"
          inputParameters:
            - name: collection
              in: path
          operations:
            - name: run-collection
              method: POST

Triggers a Power BI dataset refresh for the zone performance dashboard and notifies the ops team via Slack.

naftiko: "0.5"
info:
  label: "Power BI Zone Dashboard Refresh"
  description: "Triggers a Power BI dataset refresh for the zone performance dashboard and notifies the ops team via Slack."
  tags:
    - analytics
    - reporting
    - power-bi
    - slack
capability:
  exposes:
    - type: mcp
      namespace: bi-ops
      port: 8080
      tools:
        - name: refresh-zone-dashboard
          description: "Trigger a Power BI dataset refresh for the zone performance dataset and notify the ops Slack channel."
          inputParameters:
            - name: dataset_id
              in: body
              type: string
              description: "Power BI dataset ID."
            - name: group_id
              in: body
              type: string
              description: "Power BI workspace group ID."
          steps:
            - name: refresh-dataset
              type: call
              call: powerbi.refresh-dataset
              with:
                group_id: "{{group_id}}"
                dataset_id: "{{dataset_id}}"
            - name: notify-ops
              type: call
              call: slack.post-message
              with:
                channel: "ops-analytics"
                text: "Zone performance dashboard refreshing. Dataset: {{dataset_id}}"
  consumes:
    - type: http
      namespace: powerbi
      baseUri: "https://api.powerbi.com/v1.0/myorg"
      authentication:
        type: bearer
        token: "$secrets.powerbi_token"
      resources:
        - name: datasets
          path: "/groups/{{group_id}}/datasets/{{dataset_id}}/refreshes"
          inputParameters:
            - name: group_id
              in: path
            - name: dataset_id
              in: path
          operations:
            - name: refresh-dataset
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Prometheus for currently firing alert rules and returns active alerts with labels and values.

naftiko: "0.5"
info:
  label: "Prometheus Alert Rule Check"
  description: "Queries Prometheus for currently firing alert rules and returns active alerts with labels and values."
  tags:
    - monitoring
    - observability
    - prometheus
capability:
  exposes:
    - type: mcp
      namespace: observability
      port: 8080
      tools:
        - name: check-firing-alerts
          description: "Query Prometheus for all currently firing alerts and return their names, labels, and values."
          inputParameters:
            - name: severity
              in: body
              type: string
              description: "Alert severity filter (critical, warning)."
          call: prometheus.get-alerts
          with:
            severity: "{{severity}}"
          outputParameters:
            - name: alerts
              type: array
              mapping: "$.data.alerts"
  consumes:
    - type: http
      namespace: prometheus
      baseUri: "https://prometheus.deliveroo.net/api/v1"
      authentication:
        type: bearer
        token: "$secrets.prometheus_token"
      resources:
        - name: alerts
          path: "/alerts"
          operations:
            - name: get-alerts
              method: GET

Flushes a specific Redis cache key pattern and notifies the engineering team via Slack about the cache invalidation.

naftiko: "0.5"
info:
  label: "Redis Cache Flush"
  description: "Flushes a specific Redis cache key pattern and notifies the engineering team via Slack about the cache invalidation."
  tags:
    - engineering
    - caching
    - redis
    - slack
capability:
  exposes:
    - type: mcp
      namespace: platform-ops
      port: 8080
      tools:
        - name: flush-cache-pattern
          description: "Given a Redis key pattern, invalidate matching keys and notify the engineering Slack channel."
          inputParameters:
            - name: key_pattern
              in: body
              type: string
              description: "Redis key pattern to flush (e.g., restaurant:menu:*)."
          steps:
            - name: flush-keys
              type: call
              call: redis.delete-pattern
              with:
                pattern: "{{key_pattern}}"
            - name: notify-eng
              type: call
              call: slack.post-message
              with:
                channel: "engineering"
                text: "Redis cache flushed: pattern '{{key_pattern}}' — {{flush-keys.deleted_count}} keys removed"
  consumes:
    - type: http
      namespace: redis
      baseUri: "https://redis-api.deliveroo.net"
      authentication:
        type: bearer
        token: "$secrets.redis_api_token"
      resources:
        - name: keys
          path: "/keys/delete"
          operations:
            - name: delete-pattern
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Fetches menu updates from a restaurant partner's POS system and syncs them to the Deliveroo platform catalog, then notifies the partner success Slack channel.

naftiko: "0.5"
info:
  label: "Restaurant Menu Item Sync"
  description: "Fetches menu updates from a restaurant partner's POS system and syncs them to the Deliveroo platform catalog, then notifies the partner success Slack channel."
  tags:
    - marketplace
    - partner-management
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: partner-ops
      port: 8080
      tools:
        - name: sync-menu-items
          description: "Given a restaurant partner ID, fetch updated menu items and sync to the Deliveroo catalog. Notify partner success via Slack."
          inputParameters:
            - name: partner_id
              in: body
              type: string
              description: "Restaurant partner ID."
          steps:
            - name: get-partner-menu
              type: call
              call: salesforce.get-partner-menu
              with:
                partner_id: "{{partner_id}}"
            - name: notify-partner-success
              type: call
              call: slack.post-message
              with:
                channel: "partner-success"
                text: "Menu sync complete for partner {{partner_id}}: {{get-partner-menu.item_count}} items updated."
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: partners
          path: "/sobjects/Partner__c/{{partner_id}}"
          inputParameters:
            - name: partner_id
              in: path
          operations:
            - name: get-partner-menu
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new restaurant partner is approved in Salesforce, creates a Zendesk account, provisions a Stripe Connect account, and sends a Slack notification to the partner success team.

naftiko: "0.5"
info:
  label: "Restaurant Partner Onboarding"
  description: "When a new restaurant partner is approved in Salesforce, creates a Zendesk account, provisions a Stripe Connect account, and sends a Slack notification to the partner success team."
  tags:
    - crm
    - onboarding
    - salesforce
    - zendesk
    - stripe
    - slack
capability:
  exposes:
    - type: mcp
      namespace: partner-onboarding
      port: 8080
      tools:
        - name: onboard-restaurant-partner
          description: "Given a Salesforce account ID for a newly approved restaurant partner, create a Zendesk organization, provision a Stripe Connect account, and notify the partner success Slack channel."
          inputParameters:
            - name: salesforce_account_id
              in: body
              type: string
              description: "The Salesforce account ID of the approved restaurant partner."
            - name: partner_name
              in: body
              type: string
              description: "The legal name of the restaurant partner."
            - name: partner_email
              in: body
              type: string
              description: "Primary contact email for the restaurant partner."
          steps:
            - name: get-account
              type: call
              call: salesforce-lookup.get-account
              with:
                account_id: "{{salesforce_account_id}}"
            - name: create-zendesk-org
              type: call
              call: zendesk.create-organization
              with:
                name: "{{partner_name}}"
                external_id: "{{salesforce_account_id}}"
            - name: create-stripe-account
              type: call
              call: stripe.create-connect-account
              with:
                email: "{{partner_email}}"
                business_type: company
                country: GB
            - name: notify-team
              type: call
              call: slack.post-message
              with:
                channel: partner-success
                text: "New partner onboarded: {{partner_name}} | Zendesk: {{create-zendesk-org.id}} | Stripe: {{create-stripe-account.id}}"
  consumes:
    - type: http
      namespace: salesforce-lookup
      baseUri: "https://deliveroo.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
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: organizations
          path: "/organizations"
          operations:
            - name: create-organization
              method: POST
    - type: http
      namespace: stripe
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: connect-accounts
          path: "/accounts"
          operations:
            - name: create-connect-account
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Generates a weekly performance report for a restaurant partner by querying Snowflake for order metrics and sending the summary via Salesforce email and Slack.

naftiko: "0.5"
info:
  label: "Restaurant Partner Performance Report"
  description: "Generates a weekly performance report for a restaurant partner by querying Snowflake for order metrics and sending the summary via Salesforce email and Slack."
  tags:
    - analytics
    - partners
    - reporting
    - snowflake
    - salesforce
capability:
  exposes:
    - type: mcp
      namespace: partner-reporting
      port: 8080
      tools:
        - name: digest-partner-performance
          description: "Given a Salesforce account ID and report week, query Snowflake for order volume, acceptance rate, and average prep time, then update the Salesforce account with the summary."
          inputParameters:
            - name: salesforce_account_id
              in: body
              type: string
              description: "Salesforce account ID of the restaurant partner."
            - name: week_ending_date
              in: body
              type: string
              description: "ISO 8601 date for the end of the reporting week."
          steps:
            - name: get-metrics
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT COUNT(*) as order_count, AVG(acceptance_rate) as avg_acceptance, AVG(prep_time_minutes) as avg_prep FROM restaurant_metrics WHERE account_id = '{{salesforce_account_id}}' AND week_ending = '{{week_ending_date}}'"
            - name: update-account
              type: call
              call: salesforce.update-account
              with:
                account_id: "{{salesforce_account_id}}"
                weekly_order_count: "{{get-metrics.order_count}}"
                weekly_acceptance_rate: "{{get-metrics.avg_acceptance}}"
                weekly_avg_prep_minutes: "{{get-metrics.avg_prep}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.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: update-account
              method: PATCH

Triggers a targeted rider incentive campaign by querying Snowflake for eligible riders, creating a Salesforce campaign, and dispatching notifications via Twilio SMS.

naftiko: "0.5"
info:
  label: "Rider Incentive Campaign Launch"
  description: "Triggers a targeted rider incentive campaign by querying Snowflake for eligible riders, creating a Salesforce campaign, and dispatching notifications via Twilio SMS."
  tags:
    - marketing
    - riders
    - snowflake
    - salesforce
    - twilio
    - campaigns
capability:
  exposes:
    - type: mcp
      namespace: rider-marketing
      port: 8080
      tools:
        - name: launch-rider-incentive-campaign
          description: "Given a campaign name, incentive amount, and target zone ID, query Snowflake for eligible riders, create a Salesforce marketing campaign, and dispatch SMS notifications via Twilio."
          inputParameters:
            - name: campaign_name
              in: body
              type: string
              description: "Name of the incentive campaign."
            - name: incentive_amount_gbp
              in: body
              type: number
              description: "Bonus amount in GBP offered per qualifying delivery."
            - name: zone_id
              in: body
              type: string
              description: "Deliveroo zone ID to target for the campaign."
          steps:
            - name: query-eligible-riders
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT rider_id, phone_number FROM rider_profiles WHERE zone_id = '{{zone_id}}' AND status = 'active'"
            - name: create-campaign
              type: call
              call: salesforce-campaigns.create-campaign
              with:
                name: "{{campaign_name}}"
                status: Active
                type: Rider_Incentive
            - name: send-sms
              type: call
              call: twilio.send-message
              with:
                from: "$secrets.twilio_from_number"
                body: "You qualify for a £{{incentive_amount_gbp}} bonus this week! Complete qualifying deliveries to earn. T&Cs apply."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: salesforce-campaigns
      baseUri: "https://deliveroo.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: campaigns
          path: "/sobjects/Campaign"
          operations:
            - name: create-campaign
              method: POST
    - type: http
      namespace: twilio
      baseUri: "https://api.twilio.com/2010-04-01"
      authentication:
        type: basic
        username: "$secrets.twilio_account_sid"
        password: "$secrets.twilio_auth_token"
      resources:
        - name: messages
          path: "/Accounts/{{account_sid}}/Messages"
          inputParameters:
            - name: account_sid
              in: path
          operations:
            - name: send-message
              method: POST

When a rider's Workday record is terminated, deactivates their Stripe account, closes their Zendesk profile, and notifies the rider operations Slack channel.

naftiko: "0.5"
info:
  label: "Rider Offboarding Workflow"
  description: "When a rider's Workday record is terminated, deactivates their Stripe account, closes their Zendesk profile, and notifies the rider operations Slack channel."
  tags:
    - hr
    - offboarding
    - workday
    - stripe
    - zendesk
    - slack
capability:
  exposes:
    - type: mcp
      namespace: rider-offboarding
      port: 8080
      tools:
        - name: offboard-rider
          description: "Given a Workday employee ID for a terminated rider, deactivate their Stripe account, close their Zendesk profile, and notify the rider operations team in Slack."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "Workday worker ID of the terminated rider."
            - name: stripe_account_id
              in: body
              type: string
              description: "Stripe Connect account ID associated with the rider."
            - name: zendesk_user_id
              in: body
              type: string
              description: "Zendesk user ID of the rider."
          steps:
            - name: deactivate-stripe
              type: call
              call: stripe.reject-account
              with:
                account_id: "{{stripe_account_id}}"
                reason: "fraud"
            - name: suspend-zendesk-user
              type: call
              call: zendesk.update-user
              with:
                user_id: "{{zendesk_user_id}}"
                suspended: true
            - name: notify-rider-ops
              type: call
              call: slack.post-message
              with:
                channel: rider-operations
                text: "Rider offboarded: Workday {{workday_employee_id}} | Stripe {{stripe_account_id}} deactivated | Zendesk {{zendesk_user_id}} suspended"
  consumes:
    - type: http
      namespace: stripe
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: account-reject
          path: "/accounts/{{account_id}}/reject"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: reject-account
              method: POST
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: users
          path: "/users/{{user_id}}"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: update-user
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls weekly rider earnings from Snowflake, reconciles against Stripe payouts, and flags discrepancies in a Jira task for finance review.

naftiko: "0.5"
info:
  label: "Rider Payouts Weekly Reconciliation"
  description: "Pulls weekly rider earnings from Snowflake, reconciles against Stripe payouts, and flags discrepancies in a Jira task for finance review."
  tags:
    - finance
    - payroll
    - riders
    - snowflake
    - stripe
    - jira
capability:
  exposes:
    - type: mcp
      namespace: rider-finance
      port: 8080
      tools:
        - name: reconcile-rider-payouts
          description: "Given a week ending date, query Snowflake for rider earnings, retrieve Stripe payout data, and create a Jira task if discrepancies exceed the threshold."
          inputParameters:
            - name: week_ending_date
              in: body
              type: string
              description: "ISO 8601 date of the week ending period (e.g. 2026-03-16)."
            - name: discrepancy_threshold_gbp
              in: body
              type: number
              description: "GBP amount above which a discrepancy is flagged in Jira."
          steps:
            - name: get-earnings
              type: call
              call: snowflake-finance.execute-query
              with:
                statement: "SELECT SUM(earnings) as total FROM rider_earnings WHERE week_ending = '{{week_ending_date}}'"
            - name: get-payouts
              type: call
              call: stripe-payouts.list-payouts
              with:
                arrival_date: "{{week_ending_date}}"
                limit: 100
            - name: flag-discrepancy
              type: call
              call: jira-finance.create-issue
              with:
                project_key: FIN
                issuetype: Task
                summary: "Rider payout discrepancy detected for week ending {{week_ending_date}}"
                description: "Earnings from Snowflake: {{get-earnings.total}}\nStripe payouts: {{get-payouts.total_amount}}\nReview required."
  consumes:
    - type: http
      namespace: snowflake-finance
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: stripe-payouts
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: payouts
          path: "/payouts"
          operations:
            - name: list-payouts
              method: GET
    - type: http
      namespace: jira-finance
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Computes a partner health score from Snowflake order and acceptance rate data and updates the corresponding Salesforce account record for the partner success team.

naftiko: "0.5"
info:
  label: "Salesforce Account Health Score Update"
  description: "Computes a partner health score from Snowflake order and acceptance rate data and updates the corresponding Salesforce account record for the partner success team."
  tags:
    - crm
    - analytics
    - salesforce
    - snowflake
    - partner-success
capability:
  exposes:
    - type: mcp
      namespace: partner-health
      port: 8080
      tools:
        - name: update-partner-health-score
          description: "Given a Salesforce account ID, compute the partner health score from Snowflake metrics (order volume, acceptance rate, CSAT) and write the score back to the Salesforce account record."
          inputParameters:
            - name: salesforce_account_id
              in: body
              type: string
              description: "Salesforce account ID of the restaurant partner."
            - name: score_period_days
              in: body
              type: integer
              description: "Number of trailing days to use for the health score calculation."
          steps:
            - name: compute-score
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT ROUND((AVG(acceptance_rate) * 0.4 + AVG(csat_score) * 0.3 + LEAST(order_count / 100.0, 1) * 0.3) * 100) as health_score FROM restaurant_metrics WHERE account_id = '{{salesforce_account_id}}' AND metric_date >= DATEADD(day, -{{score_period_days}}, CURRENT_DATE)"
            - name: update-account
              type: call
              call: salesforce.update-account
              with:
                account_id: "{{salesforce_account_id}}"
                partner_health_score: "{{compute-score.health_score}}"
                health_score_updated_at: "{{snapshot_date}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.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: update-account
              method: PATCH

Enriches a Salesforce lead with restaurant performance data from Snowflake to give the sales team context during prospecting calls.

naftiko: "0.5"
info:
  label: "Salesforce Lead Enrichment from Snowflake"
  description: "Enriches a Salesforce lead with restaurant performance data from Snowflake to give the sales team context during prospecting calls."
  tags:
    - sales
    - crm
    - salesforce
    - snowflake
    - enrichment
capability:
  exposes:
    - type: mcp
      namespace: sales-intelligence
      port: 8080
      tools:
        - name: enrich-lead-with-data
          description: "Given a Salesforce lead ID and the restaurant's external identifier, pull performance benchmarks from Snowflake and update the Salesforce lead with enriched context for the sales team."
          inputParameters:
            - name: lead_id
              in: body
              type: string
              description: "Salesforce lead ID to enrich."
            - name: restaurant_external_id
              in: body
              type: string
              description: "External restaurant identifier used in the Snowflake data warehouse."
          steps:
            - name: get-benchmarks
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT category, avg_rating, estimated_weekly_orders FROM restaurant_benchmarks WHERE external_id = '{{restaurant_external_id}}' LIMIT 1"
            - name: update-lead
              type: call
              call: salesforce.update-lead
              with:
                lead_id: "{{lead_id}}"
                restaurant_category: "{{get-benchmarks.category}}"
                avg_rating: "{{get-benchmarks.avg_rating}}"
                estimated_weekly_orders: "{{get-benchmarks.estimated_weekly_orders}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.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

Queries Salesforce for the current quarter pipeline forecast by stage and posts the summary to Slack.

naftiko: "0.5"
info:
  label: "Salesforce Opportunity Forecast"
  description: "Queries Salesforce for the current quarter pipeline forecast by stage and posts the summary to Slack."
  tags:
    - sales
    - reporting
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: sales-ops
      port: 8080
      tools:
        - name: post-forecast
          description: "Run a Salesforce pipeline query and post the quarterly forecast summary to the sales Slack channel."
          inputParameters:
            - name: slack_channel
              in: body
              type: string
              description: "Slack channel for the forecast."
          steps:
            - name: query-pipeline
              type: call
              call: salesforce.query
              with:
                q: "SELECT StageName, SUM(Amount) total FROM Opportunity WHERE CloseDate = THIS_QUARTER GROUP BY StageName"
            - name: post-summary
              type: call
              call: slack.post-message
              with:
                channel: "{{slack_channel}}"
                text: "Pipeline forecast: {{query-pipeline.records}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: query
          path: "/query"
          operations:
            - name: query
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Salesforce opportunity reaches Closed Won stage, creates a matching partner record in Zendesk and notifies the account manager in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Opportunity to Partner Sync"
  description: "When a Salesforce opportunity reaches Closed Won stage, creates a matching partner record in Zendesk and notifies the account manager in Slack."
  tags:
    - sales
    - crm
    - salesforce
    - zendesk
    - slack
capability:
  exposes:
    - type: mcp
      namespace: sales-ops
      port: 8080
      tools:
        - name: sync-won-opportunity
          description: "Given a Salesforce opportunity ID that has reached Closed Won, create a Zendesk organization for the new partner and notify the account manager via Slack."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "Salesforce opportunity ID that has reached Closed Won stage."
            - name: account_manager_slack_id
              in: body
              type: string
              description: "Slack user ID of the account manager to notify."
          steps:
            - name: get-opportunity
              type: call
              call: salesforce.get-opportunity
              with:
                opportunity_id: "{{opportunity_id}}"
            - name: create-zendesk-org
              type: call
              call: zendesk.create-organization
              with:
                name: "{{get-opportunity.account_name}}"
                external_id: "{{opportunity_id}}"
            - name: notify-am
              type: call
              call: slack.post-message
              with:
                channel: "{{account_manager_slack_id}}"
                text: "Opportunity won: {{get-opportunity.name}} | Account: {{get-opportunity.account_name}} | Zendesk org created: {{create-zendesk-org.id}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.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
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: organizations
          path: "/organizations"
          operations:
            - name: create-organization
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Updates a restaurant partner's tier in Salesforce based on performance metrics and notifies the partner success team via Slack.

naftiko: "0.5"
info:
  label: "Salesforce Partner Tier Update"
  description: "Updates a restaurant partner's tier in Salesforce based on performance metrics and notifies the partner success team via Slack."
  tags:
    - partner-management
    - crm
    - salesforce
    - slack
capability:
  exposes:
    - type: mcp
      namespace: partner-ops
      port: 8080
      tools:
        - name: update-partner-tier
          description: "Given a Salesforce account ID and new tier, update the partner record and notify the partner success Slack channel."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "Salesforce account ID."
            - name: new_tier
              in: body
              type: string
              description: "New partner tier (Gold, Silver, Bronze)."
          steps:
            - name: update-account
              type: call
              call: salesforce.update-account
              with:
                account_id: "{{account_id}}"
                tier: "{{new_tier}}"
            - name: notify-team
              type: call
              call: slack.post-message
              with:
                channel: "partner-success"
                text: "Partner tier updated: {{account_id}} moved to {{new_tier}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.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: update-account
              method: PATCH
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves a restaurant partner contract from Salesforce by account ID, returning contract terms, commission rate, and renewal date.

naftiko: "0.5"
info:
  label: "Salesforce Restaurant Contract Lookup"
  description: "Retrieves a restaurant partner contract from Salesforce by account ID, returning contract terms, commission rate, and renewal date."
  tags:
    - sales
    - partner-management
    - salesforce
capability:
  exposes:
    - type: mcp
      namespace: partner-ops
      port: 8080
      tools:
        - name: get-restaurant-contract
          description: "Given a Salesforce account ID, return the active contract terms, commission rate, and renewal date."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "Salesforce account ID for the restaurant partner."
          call: salesforce.get-contract
          with:
            account_id: "{{account_id}}"
          outputParameters:
            - name: contract_status
              type: string
              mapping: "$.records[0].Status"
            - name: commission_rate
              type: number
              mapping: "$.records[0].Commission_Rate__c"
            - name: renewal_date
              type: string
              mapping: "$.records[0].EndDate"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: query
          path: "/query"
          operations:
            - name: get-contract
              method: GET

Retrieves event delivery statistics from Segment for a given source, returning success rate and error counts.

naftiko: "0.5"
info:
  label: "Segment Event Tracking Check"
  description: "Retrieves event delivery statistics from Segment for a given source, returning success rate and error counts."
  tags:
    - analytics
    - data-pipeline
    - segment
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: check-event-delivery
          description: "Given a Segment source slug, return delivery success rate and error count for the last 24 hours."
          inputParameters:
            - name: source_slug
              in: body
              type: string
              description: "Segment source slug."
          call: segment.get-delivery-overview
          with:
            source_slug: "{{source_slug}}"
          outputParameters:
            - name: success_rate
              type: number
              mapping: "$.metrics.successRate"
            - name: error_count
              type: integer
              mapping: "$.metrics.errors"
  consumes:
    - type: http
      namespace: segment
      baseUri: "https://api.segmentapis.com/v2"
      authentication:
        type: bearer
        token: "$secrets.segment_token"
      resources:
        - name: delivery
          path: "/sources/{{source_slug}}/delivery-overview"
          inputParameters:
            - name: source_slug
              in: path
          operations:
            - name: get-delivery-overview
              method: GET

When Sentry detects a new error spike, creates a Jira bug ticket and posts the error details to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "Sentry Error Alert Handler"
  description: "When Sentry detects a new error spike, creates a Jira bug ticket and posts the error details to the engineering Slack channel."
  tags:
    - engineering
    - monitoring
    - sentry
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eng-ops
      port: 8080
      tools:
        - name: handle-sentry-error
          description: "Given a Sentry issue ID, fetch error details, create a Jira bug, and notify the engineering Slack channel."
          inputParameters:
            - name: issue_id
              in: body
              type: string
              description: "Sentry issue ID."
          steps:
            - name: get-issue
              type: call
              call: sentry.get-issue
              with:
                issue_id: "{{issue_id}}"
            - name: create-bug
              type: call
              call: jira.create-issue
              with:
                project_key: "ENG"
                issuetype: "Bug"
                summary: "Sentry: {{get-issue.title}}"
                description: "Error count: {{get-issue.count}} | First seen: {{get-issue.firstSeen}}"
            - name: notify-eng
              type: call
              call: slack.post-message
              with:
                channel: "engineering"
                text: "Sentry error spike: {{get-issue.title}} ({{get-issue.count}} events) | Jira: {{create-bug.key}}"
  consumes:
    - type: http
      namespace: sentry
      baseUri: "https://sentry.io/api/0"
      authentication:
        type: bearer
        token: "$secrets.sentry_token"
      resources:
        - name: issues
          path: "/issues/{{issue_id}}/"
          inputParameters:
            - name: issue_id
              in: path
          operations:
            - name: get-issue
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates a dedicated Slack incident channel, invites the on-call team, and posts the incident summary.

naftiko: "0.5"
info:
  label: "Slack Incident Channel Creation"
  description: "Creates a dedicated Slack incident channel, invites the on-call team, and posts the incident summary."
  tags:
    - incident-management
    - collaboration
    - slack
    - pagerduty
capability:
  exposes:
    - type: mcp
      namespace: incident-ops
      port: 8080
      tools:
        - name: create-incident-channel
          description: "Given an incident title and PagerDuty incident ID, create a Slack channel, invite on-call responders, and post the incident brief."
          inputParameters:
            - name: incident_title
              in: body
              type: string
              description: "Short incident title for channel name."
            - name: pd_incident_id
              in: body
              type: string
              description: "PagerDuty incident ID."
          steps:
            - name: get-pd-incident
              type: call
              call: pagerduty.get-incident
              with:
                incident_id: "{{pd_incident_id}}"
            - name: create-channel
              type: call
              call: slack.create-channel
              with:
                name: "inc-{{incident_title}}"
            - name: post-brief
              type: call
              call: slack.post-message
              with:
                channel: "{{create-channel.id}}"
                text: "Incident: {{get-pd-incident.title}} | Status: {{get-pd-incident.status}} | PagerDuty: {{pd_incident_id}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: bearer
        token: "$secrets.pagerduty_token"
      resources:
        - name: incidents
          path: "/incidents/{{incident_id}}"
          inputParameters:
            - name: incident_id
              in: path
          operations:
            - name: get-incident
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: channels
          path: "/conversations.create"
          operations:
            - name: create-channel
              method: POST
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Runs data quality checks on core Deliveroo data pipeline tables in Snowflake and creates a Jira data quality task when anomalies are detected.

naftiko: "0.5"
info:
  label: "Snowflake Data Pipeline Quality Check"
  description: "Runs data quality checks on core Deliveroo data pipeline tables in Snowflake and creates a Jira data quality task when anomalies are detected."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - data-quality
capability:
  exposes:
    - type: mcp
      namespace: data-quality
      port: 8080
      tools:
        - name: run-pipeline-quality-check
          description: "Given a Snowflake table name and expected row count threshold, execute a data quality check and open a Jira task if the table fails validation."
          inputParameters:
            - name: table_name
              in: body
              type: string
              description: "Fully qualified Snowflake table name (e.g. raw.orders.deliveries)."
            - name: expected_min_rows
              in: body
              type: integer
              description: "Minimum expected row count for the quality check to pass."
            - name: check_date
              in: body
              type: string
              description: "ISO 8601 date for the data partition being checked."
          steps:
            - name: run-quality-query
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT COUNT(*) as row_count FROM {{table_name}} WHERE DATE(created_at) = '{{check_date}}'"
            - name: raise-quality-issue
              type: call
              call: jira.create-issue
              with:
                project_key: DATA
                issuetype: Bug
                summary: "Data quality failure: {{table_name}} on {{check_date}}"
                description: "Table {{table_name}} returned {{run-quality-query.row_count}} rows, below minimum threshold of {{expected_min_rows}} for date {{check_date}}."
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

Executes a read-only SQL query against the Snowflake order analytics warehouse and returns the result set.

naftiko: "0.5"
info:
  label: "Snowflake Order Analytics Query"
  description: "Executes a read-only SQL query against the Snowflake order analytics warehouse and returns the result set."
  tags:
    - data
    - analytics
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: run-order-query
          description: "Given a SQL query, execute it against the Snowflake order analytics warehouse and return results."
          inputParameters:
            - name: sql
              in: body
              type: string
              description: "Read-only SQL query."
          call: snowflake.execute-statement
          with:
            statement: "{{sql}}"
            warehouse: "ORDER_ANALYTICS_WH"
          outputParameters:
            - name: rows
              type: array
              mapping: "$.data"
            - name: row_count
              type: integer
              mapping: "$.resultSetMetaData.numRows"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

Checks the SonarQube quality gate status for a project and returns pass/fail with metric details.

naftiko: "0.5"
info:
  label: "SonarQube Quality Gate Check"
  description: "Checks the SonarQube quality gate status for a project and returns pass/fail with metric details."
  tags:
    - engineering
    - code-quality
    - sonarqube
capability:
  exposes:
    - type: mcp
      namespace: code-quality
      port: 8080
      tools:
        - name: check-quality-gate
          description: "Given a SonarQube project key, return the quality gate status and key metrics."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "SonarQube project key."
          call: sonarqube.get-quality-gate
          with:
            project_key: "{{project_key}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.projectStatus.status"
            - name: conditions
              type: array
              mapping: "$.projectStatus.conditions"
  consumes:
    - type: http
      namespace: sonarqube
      baseUri: "https://sonarqube.deliveroo.net/api"
      authentication:
        type: bearer
        token: "$secrets.sonarqube_token"
      resources:
        - name: quality-gates
          path: "/qualitygates/project_status"
          operations:
            - name: get-quality-gate
              method: GET

Runs a Splunk search for delivery latency metrics across zones and posts P95 latency to the ops Slack channel.

naftiko: "0.5"
info:
  label: "Splunk Delivery Latency Analysis"
  description: "Runs a Splunk search for delivery latency metrics across zones and posts P95 latency to the ops Slack channel."
  tags:
    - operations
    - analytics
    - splunk
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ops-analytics
      port: 8080
      tools:
        - name: analyze-delivery-latency
          description: "Run a Splunk search for delivery latency metrics and post P95 values to the ops Slack channel."
          inputParameters:
            - name: zone
              in: body
              type: string
              description: "Delivery zone identifier."
            - name: time_range
              in: body
              type: string
              description: "Time range (e.g., -1h, -24h)."
          steps:
            - name: run-search
              type: call
              call: splunk.search
              with:
                search: "search index=delivery zone={{zone}} | stats p95(latency_seconds) as p95_latency"
                earliest_time: "{{time_range}}"
            - name: post-results
              type: call
              call: slack.post-message
              with:
                channel: "ops-analytics"
                text: "Delivery latency for zone {{zone}}: P95 = {{run-search.p95_latency}}s"
  consumes:
    - type: http
      namespace: splunk
      baseUri: "https://deliveroo-splunk.splunkcloud.com:8089/services"
      authentication:
        type: bearer
        token: "$secrets.splunk_token"
      resources:
        - name: search
          path: "/search/jobs"
          operations:
            - name: search
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates a Statuspage incident for a service degradation and posts the status page link to the communications Slack channel.

naftiko: "0.5"
info:
  label: "Statuspage Incident Creation"
  description: "Creates a Statuspage incident for a service degradation and posts the status page link to the communications Slack channel."
  tags:
    - incident-management
    - communications
    - statuspage
    - slack
capability:
  exposes:
    - type: mcp
      namespace: incident-comms
      port: 8080
      tools:
        - name: create-statuspage-incident
          description: "Given an incident name, status, and affected component, create a Statuspage incident and notify Slack."
          inputParameters:
            - name: name
              in: body
              type: string
              description: "Incident name."
            - name: status
              in: body
              type: string
              description: "Incident status (investigating, identified, monitoring, resolved)."
            - name: component_id
              in: body
              type: string
              description: "Affected Statuspage component ID."
          steps:
            - name: create-incident
              type: call
              call: statuspage.create-incident
              with:
                name: "{{name}}"
                status: "{{status}}"
                component_ids: "{{component_id}}"
            - name: notify-comms
              type: call
              call: slack.post-message
              with:
                channel: "incident-comms"
                text: "Statuspage incident created: {{name}} | Status: {{status}} | URL: {{create-incident.shortlink}}"
  consumes:
    - type: http
      namespace: statuspage
      baseUri: "https://api.statuspage.io/v1/pages/$secrets.statuspage_page_id"
      authentication:
        type: bearer
        token: "$secrets.statuspage_api_key"
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves a Stripe customer by email address, returning customer ID, default payment method, and account balance.

naftiko: "0.5"
info:
  label: "Stripe Customer Lookup"
  description: "Retrieves a Stripe customer by email address, returning customer ID, default payment method, and account balance."
  tags:
    - payments
    - customer-data
    - stripe
capability:
  exposes:
    - type: mcp
      namespace: payments-ops
      port: 8080
      tools:
        - name: lookup-customer
          description: "Given a customer email, look up the Stripe customer record and return ID, default payment method, and balance."
          inputParameters:
            - name: email
              in: body
              type: string
              description: "Customer email address."
          call: stripe.list-customers
          with:
            email: "{{email}}"
          outputParameters:
            - name: customer_id
              type: string
              mapping: "$.data[0].id"
            - name: default_payment
              type: string
              mapping: "$.data[0].default_source"
            - name: balance
              type: integer
              mapping: "$.data[0].balance"
  consumes:
    - type: http
      namespace: stripe
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: customers
          path: "/customers"
          operations:
            - name: list-customers
              method: GET

When a Stripe dispute is created, fetches dispute details, creates a Jira finance ticket, and alerts the payments Slack channel.

naftiko: "0.5"
info:
  label: "Stripe Dispute Handler"
  description: "When a Stripe dispute is created, fetches dispute details, creates a Jira finance ticket, and alerts the payments Slack channel."
  tags:
    - finance
    - payments
    - stripe
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: payments-ops
      port: 8080
      tools:
        - name: handle-dispute
          description: "Given a Stripe dispute ID, fetch details, create a Jira ticket, and alert the payments Slack channel."
          inputParameters:
            - name: dispute_id
              in: body
              type: string
              description: "Stripe dispute ID."
          steps:
            - name: get-dispute
              type: call
              call: stripe.get-dispute
              with:
                dispute_id: "{{dispute_id}}"
            - name: create-jira
              type: call
              call: jira.create-issue
              with:
                project_key: "FIN"
                issuetype: "Task"
                summary: "Stripe dispute {{dispute_id}}: {{get-dispute.reason}} — {{get-dispute.amount}}"
            - name: alert-payments
              type: call
              call: slack.post-message
              with:
                channel: "payments-engineering"
                text: "New dispute: {{dispute_id}} | Reason: {{get-dispute.reason}} | Amount: {{get-dispute.amount}} | Jira: {{create-jira.key}}"
  consumes:
    - type: http
      namespace: stripe
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: disputes
          path: "/disputes/{{dispute_id}}"
          inputParameters:
            - name: dispute_id
              in: path
          operations:
            - name: get-dispute
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Stripe reports elevated payment failure rates, creates a Datadog alert event and notifies the payments engineering Slack channel for immediate investigation.

naftiko: "0.5"
info:
  label: "Stripe Payment Failure Alert"
  description: "When Stripe reports elevated payment failure rates, creates a Datadog alert event and notifies the payments engineering Slack channel for immediate investigation."
  tags:
    - payments
    - monitoring
    - stripe
    - datadog
    - slack
capability:
  exposes:
    - type: mcp
      namespace: payments-ops
      port: 8080
      tools:
        - name: handle-payment-failure-spike
          description: "Given a Stripe payment failure rate alert, create a Datadog event and notify the payments engineering Slack channel with failure details."
          inputParameters:
            - name: failure_rate_pct
              in: body
              type: number
              description: "Current payment failure rate as a percentage."
            - name: affected_currency
              in: body
              type: string
              description: "Currency code experiencing elevated failures (e.g. GBP, EUR)."
            - name: time_window_minutes
              in: body
              type: integer
              description: "Time window in minutes over which the failure rate was measured."
          steps:
            - name: create-dd-event
              type: call
              call: datadog.create-event
              with:
                title: "Stripe payment failures: {{failure_rate_pct}}% in {{affected_currency}}"
                text: "Failure rate {{failure_rate_pct}}% over last {{time_window_minutes}}min for currency {{affected_currency}}"
                alert_type: error
                tags: "service:payments,currency:{{affected_currency}}"
            - name: notify-payments-eng
              type: call
              call: slack.post-message
              with:
                channel: payments-engineering
                text: "Payment failure spike: {{failure_rate_pct}}% in {{affected_currency}} over {{time_window_minutes}}min | Datadog: {{create-dd-event.url}}"
  consumes:
    - 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
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves a Stripe payout by ID and returns the amount, arrival date, and status for finance reconciliation.

naftiko: "0.5"
info:
  label: "Stripe Payout Reconciliation"
  description: "Retrieves a Stripe payout by ID and returns the amount, arrival date, and status for finance reconciliation."
  tags:
    - finance
    - payments
    - stripe
capability:
  exposes:
    - type: mcp
      namespace: finance-ops
      port: 8080
      tools:
        - name: get-payout-details
          description: "Given a Stripe payout ID, return the amount, currency, arrival date, and status. Use for daily payout reconciliation."
          inputParameters:
            - name: payout_id
              in: body
              type: string
              description: "Stripe payout ID."
          call: stripe.get-payout
          with:
            payout_id: "{{payout_id}}"
          outputParameters:
            - name: amount
              type: number
              mapping: "$.amount"
            - name: currency
              type: string
              mapping: "$.currency"
            - name: arrival_date
              type: string
              mapping: "$.arrival_date"
            - name: status
              type: string
              mapping: "$.status"
  consumes:
    - type: http
      namespace: stripe
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: payouts
          path: "/payouts/{{payout_id}}"
          inputParameters:
            - name: payout_id
              in: path
          operations:
            - name: get-payout
              method: GET

Processes a customer refund via Stripe for a failed or disputed order and updates the Zendesk support ticket with the refund confirmation.

naftiko: "0.5"
info:
  label: "Stripe Refund Processing"
  description: "Processes a customer refund via Stripe for a failed or disputed order and updates the Zendesk support ticket with the refund confirmation."
  tags:
    - payments
    - customer-support
    - stripe
    - zendesk
capability:
  exposes:
    - type: mcp
      namespace: refunds
      port: 8080
      tools:
        - name: process-order-refund
          description: "Given a Stripe payment intent ID and refund amount, process the refund and update the associated Zendesk ticket with the refund confirmation and reference number."
          inputParameters:
            - name: payment_intent_id
              in: body
              type: string
              description: "Stripe payment intent ID for the order to be refunded."
            - name: refund_amount_pence
              in: body
              type: integer
              description: "Refund amount in pence (e.g. 1200 for £12.00)."
            - name: zendesk_ticket_id
              in: body
              type: string
              description: "Zendesk ticket ID to update with the refund confirmation."
            - name: reason
              in: body
              type: string
              description: "Refund reason code: requested_by_customer, fraudulent, or duplicate."
          steps:
            - name: create-refund
              type: call
              call: stripe.create-refund
              with:
                payment_intent: "{{payment_intent_id}}"
                amount: "{{refund_amount_pence}}"
                reason: "{{reason}}"
            - name: update-ticket
              type: call
              call: zendesk.update-ticket
              with:
                ticket_id: "{{zendesk_ticket_id}}"
                comment_body: "Refund processed successfully. Refund ID: {{create-refund.id}} for amount {{refund_amount_pence}}p. Status: {{create-refund.status}}"
                status: solved
  consumes:
    - type: http
      namespace: stripe
      baseUri: "https://api.stripe.com/v1"
      authentication:
        type: bearer
        token: "$secrets.stripe_secret_key"
      resources:
        - name: refunds
          path: "/refunds"
          operations:
            - name: create-refund
              method: POST
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: tickets
          path: "/tickets/{{ticket_id}}"
          inputParameters:
            - name: ticket_id
              in: path
          operations:
            - name: update-ticket
              method: PUT

Triggers a refresh of Deliveroo's key Tableau dashboards after Snowflake pipeline loads complete, ensuring leadership always see current data.

naftiko: "0.5"
info:
  label: "Tableau Dashboard Refresh on Data Load"
  description: "Triggers a refresh of Deliveroo's key Tableau dashboards after Snowflake pipeline loads complete, ensuring leadership always see current data."
  tags:
    - analytics
    - reporting
    - tableau
    - snowflake
    - data
capability:
  exposes:
    - type: mcp
      namespace: dashboard-refresh
      port: 8080
      tools:
        - name: trigger-tableau-refresh
          description: "Given a Tableau workbook ID and a Snowflake pipeline completion signal, verify the data load status and trigger a Tableau workbook refresh for leadership dashboards."
          inputParameters:
            - name: tableau_workbook_id
              in: body
              type: string
              description: "Tableau workbook ID to refresh."
            - name: pipeline_name
              in: body
              type: string
              description: "Name of the Snowflake pipeline that completed loading."
          steps:
            - name: verify-load
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT status, loaded_at FROM pipeline_runs WHERE pipeline_name = '{{pipeline_name}}' ORDER BY loaded_at DESC LIMIT 1"
            - name: refresh-workbook
              type: call
              call: tableau.refresh-workbook
              with:
                workbook_id: "{{tableau_workbook_id}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: tableau
      baseUri: "https://10ax.online.tableau.com/api/2.8"
      authentication:
        type: apikey
        key: X-Tableau-Auth
        value: "$secrets.tableau_token"
        placement: header
      resources:
        - name: workbook-refresh
          path: "/sites/{{site_id}}/workbooks/{{workbook_id}}/refresh"
          inputParameters:
            - name: site_id
              in: path
            - name: workbook_id
              in: path
          operations:
            - name: refresh-workbook
              method: POST

Triggers a Terraform Cloud plan for a workspace and posts the plan summary to a Slack channel.

naftiko: "0.5"
info:
  label: "Terraform Workspace Plan Trigger"
  description: "Triggers a Terraform Cloud plan for a workspace and posts the plan summary to a Slack channel."
  tags:
    - infrastructure
    - iac
    - terraform
    - slack
capability:
  exposes:
    - type: mcp
      namespace: infra-ops
      port: 8080
      tools:
        - name: trigger-plan
          description: "Given a Terraform Cloud workspace ID, trigger a speculative plan and post the summary to Slack."
          inputParameters:
            - name: workspace_id
              in: body
              type: string
              description: "Terraform Cloud workspace ID."
          steps:
            - name: create-run
              type: call
              call: terraform.create-run
              with:
                workspace_id: "{{workspace_id}}"
                message: "Automated plan trigger"
            - name: notify-slack
              type: call
              call: slack.post-message
              with:
                channel: "infra-ops"
                text: "Terraform plan triggered for workspace {{workspace_id}}: run ID {{create-run.id}}"
  consumes:
    - type: http
      namespace: terraform
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: runs
          path: "/runs"
          operations:
            - name: create-run
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the status of a Twilio voice call by SID, returning duration, status, and direction.

naftiko: "0.5"
info:
  label: "Twilio Call Status Lookup"
  description: "Retrieves the status of a Twilio voice call by SID, returning duration, status, and direction."
  tags:
    - communications
    - telephony
    - twilio
capability:
  exposes:
    - type: mcp
      namespace: comms-ops
      port: 8080
      tools:
        - name: get-call-status
          description: "Given a Twilio call SID, return the call status, duration, and direction."
          inputParameters:
            - name: call_sid
              in: body
              type: string
              description: "Twilio call SID."
          call: twilio.get-call
          with:
            call_sid: "{{call_sid}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.status"
            - name: duration
              type: string
              mapping: "$.duration"
            - name: direction
              type: string
              mapping: "$.direction"
  consumes:
    - type: http
      namespace: twilio
      baseUri: "https://api.twilio.com/2010-04-01/Accounts/$secrets.twilio_account_sid"
      authentication:
        type: basic
        username: "$secrets.twilio_account_sid"
        password: "$secrets.twilio_auth_token"
      resources:
        - name: calls
          path: "/Calls/{{call_sid}}.json"
          inputParameters:
            - name: call_sid
              in: path
          operations:
            - name: get-call
              method: GET

Sends an SMS notification to a rider via Twilio and logs the delivery status to Snowflake for analytics.

naftiko: "0.5"
info:
  label: "Twilio Rider SMS Notification"
  description: "Sends an SMS notification to a rider via Twilio and logs the delivery status to Snowflake for analytics."
  tags:
    - communications
    - rider-management
    - twilio
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: comms-ops
      port: 8080
      tools:
        - name: send-rider-sms
          description: "Given a rider phone number and message body, send an SMS via Twilio and log the event to Snowflake."
          inputParameters:
            - name: phone_number
              in: body
              type: string
              description: "Rider phone number in E.164 format."
            - name: message_body
              in: body
              type: string
              description: "SMS message body."
          steps:
            - name: send-sms
              type: call
              call: twilio.send-message
              with:
                to: "{{phone_number}}"
                body: "{{message_body}}"
            - name: log-event
              type: call
              call: snowflake.insert-row
              with:
                table: "RIDER_SMS_LOG"
                values:
                  phone: "{{phone_number}}"
                  message_sid: "{{send-sms.sid}}"
                  status: "{{send-sms.status}}"
  consumes:
    - type: http
      namespace: twilio
      baseUri: "https://api.twilio.com/2010-04-01/Accounts/$secrets.twilio_account_sid"
      authentication:
        type: basic
        username: "$secrets.twilio_account_sid"
        password: "$secrets.twilio_auth_token"
      resources:
        - name: messages
          path: "/Messages.json"
          operations:
            - name: send-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: insert-row
              method: POST

Looks up the delivery status of a Twilio SMS message sent to a rider or customer and returns the status for support and operations teams.

naftiko: "0.5"
info:
  label: "Twilio SMS Delivery Status Check"
  description: "Looks up the delivery status of a Twilio SMS message sent to a rider or customer and returns the status for support and operations teams."
  tags:
    - operations
    - communications
    - twilio
    - support
capability:
  exposes:
    - type: mcp
      namespace: comms-ops
      port: 8080
      tools:
        - name: get-sms-delivery-status
          description: "Given a Twilio message SID, retrieve the current delivery status of an SMS sent to a rider or customer. Use to diagnose communication failures in support investigations."
          inputParameters:
            - name: message_sid
              in: body
              type: string
              description: "The Twilio message SID (starts with SM or MM)."
          call: twilio.get-message
          with:
            message_sid: "{{message_sid}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.status"
            - name: to
              type: string
              mapping: "$.to"
            - name: date_sent
              type: string
              mapping: "$.date_sent"
            - name: error_code
              type: string
              mapping: "$.error_code"
  consumes:
    - type: http
      namespace: twilio
      baseUri: "https://api.twilio.com/2010-04-01"
      authentication:
        type: basic
        username: "$secrets.twilio_account_sid"
        password: "$secrets.twilio_auth_token"
      resources:
        - name: messages
          path: "/Accounts/{{account_sid}}/Messages/{{message_sid}}"
          inputParameters:
            - name: account_sid
              in: path
            - name: message_sid
              in: path
          operations:
            - name: get-message
              method: GET

Queries Snowflake for zone-level gross merchandise value by week and writes the revenue snapshot to a Salesforce custom object for commercial leadership reporting.

naftiko: "0.5"
info:
  label: "Weekly Zone Revenue Snapshot"
  description: "Queries Snowflake for zone-level gross merchandise value by week and writes the revenue snapshot to a Salesforce custom object for commercial leadership reporting."
  tags:
    - finance
    - analytics
    - snowflake
    - salesforce
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: revenue-reporting
      port: 8080
      tools:
        - name: snapshot-zone-revenue
          description: "Given a week ending date, query Snowflake for GMV by zone and upsert the weekly revenue records to the Salesforce ZoneRevenue__c custom object."
          inputParameters:
            - name: week_ending_date
              in: body
              type: string
              description: "ISO 8601 date of the week ending for the revenue snapshot."
          steps:
            - name: get-zone-gmv
              type: call
              call: snowflake.execute-query
              with:
                statement: "SELECT zone_id, zone_name, SUM(gmv_gbp) as total_gmv FROM zone_revenue WHERE week_ending = '{{week_ending_date}}' GROUP BY zone_id, zone_name"
            - name: upsert-revenue-record
              type: call
              call: salesforce.create-record
              with:
                object_type: ZoneRevenue__c
                week_ending: "{{week_ending_date}}"
                gmv_data: "{{get-zone-gmv.data}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST
    - type: http
      namespace: salesforce
      baseUri: "https://deliveroo.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: records
          path: "/sobjects/{{object_type}}"
          inputParameters:
            - name: object_type
              in: path
          operations:
            - name: create-record
              method: POST

Sends a WhatsApp template message to a rider via the WhatsApp Business API for delivery instructions.

naftiko: "0.5"
info:
  label: "WhatsApp Rider Communication"
  description: "Sends a WhatsApp template message to a rider via the WhatsApp Business API for delivery instructions."
  tags:
    - communications
    - rider-management
    - whatsapp
capability:
  exposes:
    - type: mcp
      namespace: rider-comms
      port: 8080
      tools:
        - name: send-rider-whatsapp
          description: "Given a rider phone number and template name, send a WhatsApp Business message."
          inputParameters:
            - name: phone_number
              in: body
              type: string
              description: "Rider phone number in E.164 format."
            - name: template_name
              in: body
              type: string
              description: "WhatsApp template name."
          call: whatsapp.send-template
          with:
            to: "{{phone_number}}"
            template: "{{template_name}}"
          outputParameters:
            - name: message_id
              type: string
              mapping: "$.messages[0].id"
            - name: status
              type: string
              mapping: "$.messages[0].message_status"
  consumes:
    - type: http
      namespace: whatsapp
      baseUri: "https://graph.facebook.com/v18.0"
      authentication:
        type: bearer
        token: "$secrets.whatsapp_token"
      resources:
        - name: messages
          path: "/{{phone_number_id}}/messages"
          operations:
            - name: send-template
              method: POST

Retrieves an employee's PTO and sick leave balances from Workday by employee ID.

naftiko: "0.5"
info:
  label: "Workday Absence Balance Lookup"
  description: "Retrieves an employee's PTO and sick leave balances from Workday by employee ID."
  tags:
    - hr
    - leave-management
    - workday
capability:
  exposes:
    - type: mcp
      namespace: hr-ops
      port: 8080
      tools:
        - name: get-absence-balance
          description: "Given a Workday employee ID, return PTO balance, sick leave balance, and next accrual date."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
          call: workday.get-balance
          with:
            employee_id: "{{employee_id}}"
          outputParameters:
            - name: pto_balance
              type: number
              mapping: "$.Worker.TimeOff.PTO_Balance"
            - name: sick_balance
              type: number
              mapping: "$.Worker.TimeOff.Sick_Balance"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd5-impl-services1.workday.com/ccx/service/deliveroo"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: absence
          path: "/Human_Resources/v40.0/Get_Workers"
          operations:
            - name: get-balance
              method: GET

When a compensation change is approved in Workday, sends a confirmation email and notifies HR via Slack.

naftiko: "0.5"
info:
  label: "Workday Compensation Change Alert"
  description: "When a compensation change is approved in Workday, sends a confirmation email and notifies HR via Slack."
  tags:
    - hr
    - compensation
    - workday
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-ops
      port: 8080
      tools:
        - name: notify-comp-change
          description: "Given a Workday employee ID and compensation event, fetch details and notify HR via Slack."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
            - name: event_id
              in: body
              type: string
              description: "Compensation event ID."
          steps:
            - name: get-event
              type: call
              call: workday.get-comp-event
              with:
                employee_id: "{{employee_id}}"
                event_id: "{{event_id}}"
            - name: notify-hr
              type: call
              call: slack.post-message
              with:
                channel: "hr-notifications"
                text: "Compensation change for {{employee_id}}: effective {{get-event.effective_date}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd5-impl-services1.workday.com/ccx/service/deliveroo"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: compensation
          path: "/Compensation/v40.0"
          operations:
            - name: get-comp-event
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an employee's role changes in Workday, updates their GitHub team memberships and notifies the engineering manager in Slack.

naftiko: "0.5"
info:
  label: "Workday Employee Role Change Provisioning"
  description: "When an employee's role changes in Workday, updates their GitHub team memberships and notifies the engineering manager in Slack."
  tags:
    - hr
    - access-management
    - workday
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: role-provisioning
      port: 8080
      tools:
        - name: provision-role-change
          description: "Given a Workday employee ID, their old and new GitHub team slugs, update GitHub team memberships accordingly and notify the engineering manager in Slack."
          inputParameters:
            - name: workday_employee_id
              in: body
              type: string
              description: "Workday worker ID of the employee changing roles."
            - name: github_username
              in: body
              type: string
              description: "GitHub username of the employee."
            - name: old_team_slug
              in: body
              type: string
              description: "GitHub team slug for the employee's previous team."
            - name: new_team_slug
              in: body
              type: string
              description: "GitHub team slug for the employee's new team."
            - name: manager_slack_id
              in: body
              type: string
              description: "Slack user ID of the new engineering manager."
          steps:
            - name: remove-old-team
              type: call
              call: github.remove-team-member
              with:
                org: deliveroo
                team_slug: "{{old_team_slug}}"
                username: "{{github_username}}"
            - name: add-new-team
              type: call
              call: github-new-team.add-team-member
              with:
                org: deliveroo
                team_slug: "{{new_team_slug}}"
                username: "{{github_username}}"
            - name: notify-manager
              type: call
              call: slack.post-message
              with:
                channel: "{{manager_slack_id}}"
                text: "@{{github_username}} has been moved from team {{old_team_slug}} to {{new_team_slug}} following role change in Workday ({{workday_employee_id}})."
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: team-members
          path: "/orgs/deliveroo/teams/{{team_slug}}/memberships/{{username}}"
          inputParameters:
            - name: team_slug
              in: path
            - name: username
              in: path
          operations:
            - name: remove-team-member
              method: DELETE
    - type: http
      namespace: github-new-team
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: team-members
          path: "/orgs/deliveroo/teams/{{team_slug}}/memberships/{{username}}"
          inputParameters:
            - name: team_slug
              in: path
            - name: username
              in: path
          operations:
            - name: add-team-member
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Creates a new position requisition in Workday and posts the job details to the recruiting Slack channel.

naftiko: "0.5"
info:
  label: "Workday New Position Requisition"
  description: "Creates a new position requisition in Workday and posts the job details to the recruiting Slack channel."
  tags:
    - hr
    - recruiting
    - workday
    - slack
capability:
  exposes:
    - type: mcp
      namespace: recruiting-ops
      port: 8080
      tools:
        - name: create-requisition
          description: "Given job title, department, and hiring manager, create a Workday position requisition and notify the recruiting Slack channel."
          inputParameters:
            - name: job_title
              in: body
              type: string
              description: "Job title for the new position."
            - name: department
              in: body
              type: string
              description: "Department name."
            - name: hiring_manager_id
              in: body
              type: string
              description: "Workday ID of the hiring manager."
          steps:
            - name: create-req
              type: call
              call: workday.create-requisition
              with:
                title: "{{job_title}}"
                department: "{{department}}"
                manager_id: "{{hiring_manager_id}}"
            - name: notify-recruiting
              type: call
              call: slack.post-message
              with:
                channel: "recruiting"
                text: "New requisition created: {{job_title}} in {{department}} | Req ID: {{create-req.requisition_id}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd5-impl-services1.workday.com/ccx/service/deliveroo"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: requisitions
          path: "/Recruiting/v40.0"
          operations:
            - name: create-requisition
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the manager and direct reports for a Workday employee by employee ID.

naftiko: "0.5"
info:
  label: "Workday Org Chart Lookup"
  description: "Retrieves the manager and direct reports for a Workday employee by employee ID."
  tags:
    - hr
    - workforce
    - workday
capability:
  exposes:
    - type: mcp
      namespace: hr-ops
      port: 8080
      tools:
        - name: get-org-chart
          description: "Given a Workday employee ID, return manager name, title, and list of direct reports."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "Workday employee ID."
          call: workday.get-worker
          with:
            employee_id: "{{employee_id}}"
          outputParameters:
            - name: manager
              type: string
              mapping: "$.Worker.Manager.Name"
            - name: direct_reports
              type: array
              mapping: "$.Worker.DirectReports[*].Name"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd5-impl-services1.workday.com/ccx/service/deliveroo"
      authentication:
        type: basic
        username: "$secrets.workday_user"
        password: "$secrets.workday_password"
      resources:
        - name: workers
          path: "/Human_Resources/v40.0/Get_Workers"
          operations:
            - name: get-worker
              method: GET

When a new position requisition is submitted in Workday, creates a Jira approval task for the hiring manager and notifies the talent acquisition Slack channel.

naftiko: "0.5"
info:
  label: "Workday Position Requisition Approval"
  description: "When a new position requisition is submitted in Workday, creates a Jira approval task for the hiring manager and notifies the talent acquisition Slack channel."
  tags:
    - hr
    - recruiting
    - workday
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: talent-acquisition
      port: 8080
      tools:
        - name: initiate-position-approval
          description: "Given a Workday position requisition ID, create a Jira approval task and notify the talent acquisition Slack channel to begin the hiring workflow."
          inputParameters:
            - name: requisition_id
              in: body
              type: string
              description: "Workday position requisition ID submitted for approval."
            - name: job_title
              in: body
              type: string
              description: "Job title for the open position."
            - name: department
              in: body
              type: string
              description: "Department requesting the new headcount."
            - name: hiring_manager_slack_id
              in: body
              type: string
              description: "Slack user ID of the hiring manager."
          steps:
            - name: create-approval-task
              type: call
              call: jira.create-issue
              with:
                project_key: HR
                issuetype: Task
                summary: "Position approval: {{job_title}} — {{department}}"
                description: "Workday requisition {{requisition_id}} for {{job_title}} in {{department}} is pending approval."
            - name: notify-ta
              type: call
              call: slack.post-message
              with:
                channel: talent-acquisition
                text: "New position requisition: {{job_title}} in {{department}} | Jira: {{create-approval-task.key}} | Hiring manager: <@{{hiring_manager_slack_id}}>"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: bearer
        token: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves CSAT scores from Zendesk for a given date range and writes the aggregated results to Snowflake for customer experience reporting.

naftiko: "0.5"
info:
  label: "Zendesk Customer Satisfaction Score Tracker"
  description: "Retrieves CSAT scores from Zendesk for a given date range and writes the aggregated results to Snowflake for customer experience reporting."
  tags:
    - customer-support
    - analytics
    - zendesk
    - snowflake
    - csat
capability:
  exposes:
    - type: mcp
      namespace: csat-reporting
      port: 8080
      tools:
        - name: track-csat-scores
          description: "Given a date range, retrieve CSAT satisfaction ratings from Zendesk and write the aggregated score to Snowflake for CX trend analysis."
          inputParameters:
            - name: start_date
              in: body
              type: string
              description: "ISO 8601 start date for the CSAT report period."
            - name: end_date
              in: body
              type: string
              description: "ISO 8601 end date for the CSAT report period."
          steps:
            - name: get-satisfaction-ratings
              type: call
              call: zendesk.list-satisfaction-ratings
              with:
                start_time: "{{start_date}}"
                end_time: "{{end_date}}"
            - name: store-scores
              type: call
              call: snowflake.execute-query
              with:
                statement: "INSERT INTO csat_scores (period_start, period_end, avg_score, total_responses) VALUES ('{{start_date}}', '{{end_date}}', {{get-satisfaction-ratings.avg_score}}, {{get-satisfaction-ratings.count}})"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: satisfaction-ratings
          path: "/satisfaction_ratings"
          inputParameters:
            - name: start_time
              in: query
            - name: end_time
              in: query
          operations:
            - name: list-satisfaction-ratings
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://deliveroo.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-query
              method: POST

Retrieves CSAT scores from Zendesk for a given period and returns the satisfaction percentage and response count.

naftiko: "0.5"
info:
  label: "Zendesk Customer Satisfaction Trend"
  description: "Retrieves CSAT scores from Zendesk for a given period and returns the satisfaction percentage and response count."
  tags:
    - support
    - customer-experience
    - zendesk
capability:
  exposes:
    - type: mcp
      namespace: cx-ops
      port: 8080
      tools:
        - name: get-csat-trend
          description: "Fetch Zendesk satisfaction ratings for a date range and return the CSAT percentage."
          inputParameters:
            - name: start_date
              in: body
              type: string
              description: "Start date (YYYY-MM-DD)."
          call: zendesk.get-satisfaction-ratings
          with:
            start_time: "{{start_date}}"
          outputParameters:
            - name: score
              type: string
              mapping: "$.satisfaction_ratings[0].score"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: satisfaction-ratings
          path: "/satisfaction_ratings.json"
          operations:
            - name: get-satisfaction-ratings
              method: GET

When a Zendesk rider complaint ticket reaches high priority, creates a Jira operations ticket and alerts the rider-ops Slack channel.

naftiko: "0.5"
info:
  label: "Zendesk Rider Complaint Escalation"
  description: "When a Zendesk rider complaint ticket reaches high priority, creates a Jira operations ticket and alerts the rider-ops Slack channel."
  tags:
    - support
    - operations
    - zendesk
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: rider-ops
      port: 8080
      tools:
        - name: escalate-rider-complaint
          description: "Given a Zendesk ticket ID for a rider complaint, create a Jira ops ticket and notify the rider-ops Slack channel."
          inputParameters:
            - name: ticket_id
              in: body
              type: string
              description: "Zendesk ticket ID."
          steps:
            - name: get-ticket
              type: call
              call: zendesk.get-ticket
              with:
                ticket_id: "{{ticket_id}}"
            - name: create-jira
              type: call
              call: jira.create-issue
              with:
                project_key: "RIDEROPS"
                issuetype: "Task"
                summary: "Rider complaint: {{get-ticket.subject}}"
                description: "Zendesk ticket {{ticket_id}}: {{get-ticket.description}}"
            - name: alert-slack
              type: call
              call: slack.post-message
              with:
                channel: "rider-ops"
                text: "Rider complaint escalated: {{get-ticket.subject}} | Jira: {{create-jira.key}} | Zendesk: {{ticket_id}}"
  consumes:
    - type: http
      namespace: zendesk
      baseUri: "https://deliveroo.zendesk.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.zendesk_token"
      resources:
        - name: tickets
          path: "/tickets/{{ticket_id}}.json"
          inputParameters:
            - name: ticket_id
              in: path
          operations:
            - name: get-ticket
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://deliveroo.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_bot_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST