Uber Capabilities

When an accessibility complaint is filed, creates a Jira ticket tagged for the accessibility team, notifies the product channel in Slack, and logs the issue in Snowflake for compliance tracking.

naftiko: "0.5"
info:
  label: "Accessibility Issue Triage"
  description: "When an accessibility complaint is filed, creates a Jira ticket tagged for the accessibility team, notifies the product channel in Slack, and logs the issue in Snowflake for compliance tracking."
  tags:
    - accessibility
    - jira
    - slack
    - snowflake
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: accessibility-ops
      port: 8080
      tools:
        - name: triage-accessibility-issue
          description: "Given an accessibility complaint, create a Jira ticket, notify the product team, and log for compliance."
          inputParameters:
            - name: issue_description
              in: body
              type: string
              description: "Description of the accessibility issue."
            - name: platform
              in: body
              type: string
              description: "Platform affected (ios, android, web)."
            - name: reporter_email
              in: body
              type: string
              description: "Email of the person reporting."
          steps:
            - name: create-a11y-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "A11Y"
                issuetype: "Bug"
                summary: "Accessibility issue on {{platform}}: {{issue_description}}"
                labels: "accessibility,{{platform}}"
            - name: notify-product
              type: call
              call: "slack.post-message"
              with:
                channel: "accessibility-team"
                text: "New accessibility issue on {{platform}}: {{issue_description}}. Jira: {{create-a11y-ticket.key}}"
            - name: log-compliance
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO compliance.accessibility_issues (platform, description, ticket_key, reported_at) VALUES ('{{platform}}', '{{issue_description}}', '{{create-a11y-ticket.key}}', CURRENT_TIMESTAMP())"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

When a large GitHub PR is opened, uses Anthropic to summarize the changes, then posts the AI summary as a PR comment and notifies the team in Slack.

naftiko: "0.5"
info:
  label: "AI-Assisted Code Review Summary"
  description: "When a large GitHub PR is opened, uses Anthropic to summarize the changes, then posts the AI summary as a PR comment and notifies the team in Slack."
  tags:
    - engineering
    - github
    - anthropic
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: code-review
      port: 8080
      tools:
        - name: summarize-pr
          description: "Given a GitHub PR number and repo, fetch the diff, summarize it with Anthropic, post as a PR comment, and notify Slack."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
            - name: pr_number
              in: body
              type: number
              description: "The pull request number."
          steps:
            - name: get-pr-diff
              type: call
              call: "github.get-pr"
              with:
                repo: "{{repo_name}}"
                pull_number: "{{pr_number}}"
            - name: summarize-changes
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-3-5-sonnet-20241022"
                max_tokens: 1000
                messages: "[{\"role\": \"user\", \"content\": \"Summarize this PR for code review. Focus on risk areas and key changes:\\n{{get-pr-diff.body}}\"}]"
            - name: post-pr-comment
              type: call
              call: "github.create-pr-comment"
              with:
                repo: "{{repo_name}}"
                pull_number: "{{pr_number}}"
                body: "AI Review Summary:\\n{{summarize-changes.content}}"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "code-reviews"
                text: "AI summary posted for PR #{{pr_number}} in {{repo_name}}: {{summarize-changes.content}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/uber/{{repo}}/pulls/{{pull_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: pull_number
              in: path
          operations:
            - name: get-pr
              method: GET
        - name: pr-comments
          path: "/repos/uber/{{repo}}/issues/{{pull_number}}/comments"
          inputParameters:
            - name: repo
              in: path
            - name: pull_number
              in: path
          operations:
            - name: create-pr-comment
              method: POST
    - type: http
      namespace: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When performance review cycle opens, creates Jira tracking tickets for each team, sends a kickoff message via Slack, and logs the cycle in Snowflake.

naftiko: "0.5"
info:
  label: "Annual Performance Review Launcher"
  description: "When performance review cycle opens, creates Jira tracking tickets for each team, sends a kickoff message via Slack, and logs the cycle in Snowflake."
  tags:
    - hr
    - jira
    - slack
    - snowflake
    - performance
capability:
  exposes:
    - type: mcp
      namespace: hr-perf
      port: 8080
      tools:
        - name: launch-review-cycle
          description: "Given a review cycle name and deadline, create tracking tickets, notify all teams, and log the cycle."
          inputParameters:
            - name: cycle_name
              in: body
              type: string
              description: "The performance review cycle name (e.g., H1-2026)."
            - name: deadline
              in: body
              type: string
              description: "Review submission deadline."
          steps:
            - name: create-tracking-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "HR"
                issuetype: "Epic"
                summary: "Performance review cycle: {{cycle_name}} — due {{deadline}}"
            - name: announce-cycle
              type: call
              call: "slack.post-message"
              with:
                channel: "all-managers"
                text: "Performance review cycle {{cycle_name}} is now open! Deadline: {{deadline}}. Tracking: {{create-tracking-epic.key}}"
            - name: log-cycle
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO hr.review_cycles (cycle_name, deadline, launched_at) VALUES ('{{cycle_name}}', '{{deadline}}', CURRENT_TIMESTAMP())"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

When an API rate limit breach is detected by Datadog, identifies the offending client, creates a Jira ticket, and notifies the API platform team via Slack.

naftiko: "0.5"
info:
  label: "API Rate Limit Breach Handler"
  description: "When an API rate limit breach is detected by Datadog, identifies the offending client, creates a Jira ticket, and notifies the API platform team via Slack."
  tags:
    - api-management
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: api-platform
      port: 8080
      tools:
        - name: handle-rate-limit-breach
          description: "Given an API endpoint and offending client, create a Jira investigation ticket and notify the platform team."
          inputParameters:
            - name: api_endpoint
              in: body
              type: string
              description: "The API endpoint experiencing rate limit breaches."
            - name: client_id
              in: body
              type: string
              description: "The API client ID exceeding the rate limit."
            - name: request_count
              in: body
              type: number
              description: "Number of requests in the breach window."
          steps:
            - name: create-investigation
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PLATFORM"
                issuetype: "Bug"
                summary: "Rate limit breach: {{api_endpoint}} by client {{client_id}}"
                description: "Client {{client_id}} made {{request_count}} requests to {{api_endpoint}} exceeding rate limits."
            - name: notify-platform-team
              type: call
              call: "slack.post-message"
              with:
                channel: "api-platform-alerts"
                text: "Rate limit breach: {{client_id}} on {{api_endpoint}} ({{request_count}} reqs). Jira: {{create-investigation.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Snowflake for autonomous vehicle fleet telemetry data, creates a Jira report ticket, and posts fleet health to the AV engineering Slack channel.

naftiko: "0.5"
info:
  label: "Autonomous Vehicle Telemetry Reporter"
  description: "Queries Snowflake for autonomous vehicle fleet telemetry data, creates a Jira report ticket, and posts fleet health to the AV engineering Slack channel."
  tags:
    - autonomous-vehicles
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: av-ops
      port: 8080
      tools:
        - name: generate-av-telemetry-report
          description: "Given a fleet region, query telemetry data, create a report ticket, and notify the AV team."
          inputParameters:
            - name: fleet_region
              in: body
              type: string
              description: "The fleet operating region."
            - name: report_date
              in: body
              type: string
              description: "Report date in YYYY-MM-DD format."
          steps:
            - name: query-telemetry
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT vehicle_id, miles_driven, disengagements, avg_speed FROM av.fleet_telemetry WHERE region='{{fleet_region}}' AND date='{{report_date}}'"
            - name: create-report-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "AV"
                issuetype: "Task"
                summary: "Fleet telemetry report: {{fleet_region}} — {{report_date}}"
                description: "Data: {{query-telemetry.data}}"
            - name: notify-av-team
              type: call
              call: "slack.post-message"
              with:
                channel: "av-engineering"
                text: "Fleet telemetry for {{fleet_region}} ({{report_date}}): {{query-telemetry.data}}. Report: {{create-report-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current state and health status of an AWS EC2 instance by instance ID.

naftiko: "0.5"
info:
  label: "AWS EC2 Instance Status Check"
  description: "Retrieves the current state and health status of an AWS EC2 instance by instance ID."
  tags:
    - infrastructure
    - aws
    - ec2
capability:
  exposes:
    - type: mcp
      namespace: cloud-ops
      port: 8080
      tools:
        - name: check-ec2-status
          description: "Given an EC2 instance ID, return its current state, status checks, and instance type. Use for infrastructure troubleshooting."
          inputParameters:
            - name: instance_id
              in: body
              type: string
              description: "The EC2 instance ID."
          call: "aws-ec2.describe-instance"
          with:
            instance_id: "{{instance_id}}"
          outputParameters:
            - name: state
              type: string
              mapping: "$.Reservations[0].Instances[0].State.Name"
            - name: instance_type
              type: string
              mapping: "$.Reservations[0].Instances[0].InstanceType"
  consumes:
    - type: http
      namespace: aws-ec2
      baseUri: "https://ec2.amazonaws.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.aws_auth_header"
        placement: header
      resources:
        - name: instances
          path: "/?Action=DescribeInstances&InstanceId.1={{instance_id}}"
          inputParameters:
            - name: instance_id
              in: query
          operations:
            - name: describe-instance
              method: GET

When CI build times regress beyond threshold, queries Snowflake for build metrics, creates a Jira optimization ticket, and alerts the developer productivity Slack channel.

naftiko: "0.5"
info:
  label: "CI Build Time Regression Alert"
  description: "When CI build times regress beyond threshold, queries Snowflake for build metrics, creates a Jira optimization ticket, and alerts the developer productivity Slack channel."
  tags:
    - cicd
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ci-perf
      port: 8080
      tools:
        - name: alert-build-regression
          description: "Given a repo and current build time, compare against baseline, create a ticket, and notify the team."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The repository name."
            - name: current_build_time_s
              in: body
              type: number
              description: "Current build time in seconds."
            - name: baseline_build_time_s
              in: body
              type: number
              description: "Baseline build time in seconds."
          steps:
            - name: log-regression
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO eng.build_regressions (repo, current_time_s, baseline_time_s, detected_at) VALUES ('{{repo_name}}', {{current_build_time_s}}, {{baseline_build_time_s}}, CURRENT_TIMESTAMP())"
            - name: create-optimization-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DEVPROD"
                issuetype: "Bug"
                summary: "CI build regression: {{repo_name}} ({{current_build_time_s}}s vs {{baseline_build_time_s}}s)"
            - name: alert-devprod
              type: call
              call: "slack.post-message"
              with:
                channel: "developer-productivity"
                text: "CI build time regression: {{repo_name}} now {{current_build_time_s}}s (baseline: {{baseline_build_time_s}}s). Ticket: {{create-optimization-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a GitHub Actions workflow fails on a protected branch, creates a Jira bug, posts a Datadog deployment marker, and alerts the owning team's Slack channel.

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

When AWS Cost Anomaly Detection fires an alert, creates a Datadog event, opens a Jira FinOps investigation ticket, and notifies the cloud cost Slack channel.

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

Audits AWS resources for missing mandatory tags, creates Jira tickets for non-compliant resources, and posts a compliance report to the platform Slack channel.

naftiko: "0.5"
info:
  label: "Cloud Resource Tagging Compliance"
  description: "Audits AWS resources for missing mandatory tags, creates Jira tickets for non-compliant resources, and posts a compliance report to the platform Slack channel."
  tags:
    - finops
    - aws
    - jira
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: cloud-compliance
      port: 8080
      tools:
        - name: audit-resource-tags
          description: "Given a required tag key, find non-compliant resources, create tickets, and report."
          inputParameters:
            - name: required_tag
              in: body
              type: string
              description: "The mandatory tag key to check."
            - name: resource_type
              in: body
              type: string
              description: "AWS resource type to audit."
          steps:
            - name: create-compliance-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "CLOUD"
                issuetype: "Task"
                summary: "Tag compliance audit: {{required_tag}} on {{resource_type}}"
            - name: report-to-platform
              type: call
              call: "slack.post-message"
              with:
                channel: "platform-engineering"
                text: "Cloud tag compliance audit: Checking {{required_tag}} on {{resource_type}}. Tracking: {{create-compliance-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When compliance training deadlines approach, queries Workday for overdue employees, sends reminders via Slack, and creates a Jira tracking ticket for the compliance team.

naftiko: "0.5"
info:
  label: "Compliance Training Overdue Reminder"
  description: "When compliance training deadlines approach, queries Workday for overdue employees, sends reminders via Slack, and creates a Jira tracking ticket for the compliance team."
  tags:
    - compliance
    - workday
    - slack
    - jira
capability:
  exposes:
    - type: mcp
      namespace: compliance-ops
      port: 8080
      tools:
        - name: send-training-reminders
          description: "Given a training program name, find overdue employees, send reminders, and create a compliance tracking ticket."
          inputParameters:
            - name: training_program
              in: body
              type: string
              description: "The compliance training program name."
            - name: deadline_date
              in: body
              type: string
              description: "The training deadline in YYYY-MM-DD format."
          steps:
            - name: create-compliance-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "COMPLY"
                issuetype: "Task"
                summary: "Overdue training: {{training_program}} — deadline {{deadline_date}}"
            - name: notify-compliance
              type: call
              call: "slack.post-message"
              with:
                channel: "compliance-alerts"
                text: "Training reminder: {{training_program}} deadline is {{deadline_date}}. Tracking: {{create-compliance-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the latest version number and last-modified timestamp of a Confluence page by ID.

naftiko: "0.5"
info:
  label: "Confluence Page Version Lookup"
  description: "Retrieves the latest version number and last-modified timestamp of a Confluence page by ID."
  tags:
    - documentation
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: docs-ops
      port: 8080
      tools:
        - name: get-page-version
          description: "Given a Confluence page ID, return its latest version number, title, and last update time. Use for documentation freshness audits."
          inputParameters:
            - name: page_id
              in: body
              type: string
              description: "The Confluence page ID."
          call: "confluence-pages.get-page"
          with:
            page_id: "{{page_id}}"
          outputParameters:
            - name: title
              type: string
              mapping: "$.title"
            - name: version
              type: number
              mapping: "$.version.number"
            - name: last_updated
              type: string
              mapping: "$.version.when"
  consumes:
    - type: http
      namespace: confluence-pages
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content/{{page_id}}"
          inputParameters:
            - name: page_id
              in: path
          operations:
            - name: get-page
              method: GET

Queries Confluence for runbook pages not updated in 90 days, creates Jira tickets for each stale runbook, and posts a summary to the SRE Slack channel.

naftiko: "0.5"
info:
  label: "Confluence Runbook Expiration Audit"
  description: "Queries Confluence for runbook pages not updated in 90 days, creates Jira tickets for each stale runbook, and posts a summary to the SRE Slack channel."
  tags:
    - documentation
    - confluence
    - jira
    - slack
    - sre
capability:
  exposes:
    - type: mcp
      namespace: runbook-audit
      port: 8080
      tools:
        - name: audit-stale-runbooks
          description: "Given a Confluence space key, find stale runbooks, create Jira tickets, and alert SRE."
          inputParameters:
            - name: space_key
              in: body
              type: string
              description: "The Confluence space key to audit."
            - name: staleness_days
              in: body
              type: number
              description: "Number of days since last update to consider stale."
          steps:
            - name: find-stale-pages
              type: call
              call: "confluence.search-content"
              with:
                cql: "space={{space_key}} AND label=runbook AND lastModified<now('-{{staleness_days}}d')"
            - name: create-review-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SRE"
                issuetype: "Task"
                summary: "Stale runbook audit: {{find-stale-pages.size}} runbooks need review in {{space_key}}"
            - name: notify-sre
              type: call
              call: "slack.post-message"
              with:
                channel: "sre-team"
                text: "Runbook audit: {{find-stale-pages.size}} stale runbooks found in {{space_key}} (>{{staleness_days}} days). Jira: {{create-review-ticket.key}}"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: search
          path: "/search"
          operations:
            - name: search-content
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Scans Confluence engineering runbooks for staleness (not updated in 90 days), creates Jira tasks for owners to refresh them, and posts an audit summary to the engineering Slack channel.

naftiko: "0.5"
info:
  label: "Confluence Technical Runbook Audit"
  description: "Scans Confluence engineering runbooks for staleness (not updated in 90 days), creates Jira tasks for owners to refresh them, and posts an audit summary to the engineering Slack channel."
  tags:
    - devops
    - documentation
    - confluence
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: runbook-quality
      port: 8080
      tools:
        - name: audit-runbook-freshness
          description: "Given a Confluence space key, find all runbooks not updated in 90 days, create Jira refresh tasks for each owner, and post a stale runbook digest to Slack."
          inputParameters:
            - name: space_key
              in: body
              type: string
              description: "Confluence space key for engineering runbooks (e.g., RUNBOOKS)."
            - name: eng_channel
              in: body
              type: string
              description: "Slack channel for the engineering on-call team."
          steps:
            - name: get-stale-runbooks
              type: call
              call: "confluence.search-stale-pages"
              with:
                spaceKey: "{{space_key}}"
                label: "runbook"
            - name: create-refresh-task
              type: call
              call: "jira-runbook.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Task"
                summary: "Runbook refresh required: {{space_key}} — {{get-stale-runbooks.count}} stale runbooks"
                description: "Stale runbooks in {{space_key}}: {{get-stale-runbooks.page_titles}}"
            - name: post-audit-digest
              type: call
              call: "slack-runbook.post-message"
              with:
                channel: "{{eng_channel}}"
                text: "Runbook Audit: Space {{space_key}} | Stale (90+ days): {{get-stale-runbooks.count}} | Jira refresh task: {{create-refresh-task.key}}"
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: pages
          path: "/content/search"
          inputParameters:
            - name: spaceKey
              in: query
            - name: label
              in: query
          operations:
            - name: search-stale-pages
              method: GET
    - type: http
      namespace: jira-runbook
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-runbook
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When AWS cloud spend exceeds a budget threshold, queries cost data, creates a Jira ticket for the finance team, and alerts the cost center owner via Slack.

naftiko: "0.5"
info:
  label: "Cost Center Budget Alert"
  description: "When AWS cloud spend exceeds a budget threshold, queries cost data, creates a Jira ticket for the finance team, and alerts the cost center owner via Slack."
  tags:
    - finops
    - aws
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: finops
      port: 8080
      tools:
        - name: alert-budget-overspend
          description: "Given a cost center and spend threshold, fetch current spend, create a Jira ticket, and notify the owner."
          inputParameters:
            - name: cost_center
              in: body
              type: string
              description: "The cost center identifier."
            - name: threshold_pct
              in: body
              type: number
              description: "The budget threshold percentage exceeded."
            - name: owner_channel
              in: body
              type: string
              description: "Slack channel for the cost center owner."
          steps:
            - name: create-budget-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "FINOPS"
                issuetype: "Task"
                summary: "Budget alert: {{cost_center}} at {{threshold_pct}}% of budget"
            - name: notify-owner
              type: call
              call: "slack.post-message"
              with:
                channel: "{{owner_channel}}"
                text: "Budget alert: Cost center {{cost_center}} has reached {{threshold_pct}}% of its monthly budget. Review: {{create-budget-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When CrowdStrike detects a high-severity endpoint threat on an Uber-managed device, creates a ServiceNow security incident, posts a Slack alert to the SOC, and logs a Datadog security event.

naftiko: "0.5"
info:
  label: "CrowdStrike Endpoint Security Alert"
  description: "When CrowdStrike detects a high-severity endpoint threat on an Uber-managed device, creates a ServiceNow security incident, posts a Slack alert to the SOC, and logs a Datadog security event."
  tags:
    - security
    - endpoint
    - crowdstrike
    - servicenow
    - slack
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: endpoint-security
      port: 8080
      tools:
        - name: handle-endpoint-threat
          description: "Given a CrowdStrike detection event with hostname and severity, create a ServiceNow security incident, alert the SOC via Slack, and log a Datadog security event for correlation."
          inputParameters:
            - name: detection_id
              in: body
              type: string
              description: "The CrowdStrike detection ID."
            - name: hostname
              in: body
              type: string
              description: "The hostname of the affected endpoint."
            - name: severity
              in: body
              type: string
              description: "Threat severity: critical, high, medium, low."
            - name: tactic
              in: body
              type: string
              description: "MITRE ATT&CK tactic of the detected threat."
          steps:
            - name: create-security-incident
              type: call
              call: "servicenow-sec.create-incident"
              with:
                short_description: "Endpoint threat: {{hostname}} — {{severity}} — {{tactic}}"
                category: "security"
                priority: "1"
                description: "Detection ID: {{detection_id}}"
            - name: alert-soc
              type: call
              call: "slack-soc.post-message"
              with:
                channel: "soc-alerts"
                text: "ENDPOINT THREAT: {{hostname}} | Severity: {{severity}} | Tactic: {{tactic}} | Detection: {{detection_id}} | ServiceNow: {{create-security-incident.number}}"
            - name: log-datadog-event
              type: call
              call: "datadog-sec.create-event"
              with:
                title: "CrowdStrike: {{tactic}} on {{hostname}}"
                text: "Detection {{detection_id}}. Severity: {{severity}}. ServiceNow: {{create-security-incident.number}}"
                alert_type: "error"
  consumes:
    - type: http
      namespace: servicenow-sec
      baseUri: "https://uber.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-soc
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: datadog-sec
      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

Retrieves the number of active detections for a given hostname in CrowdStrike Falcon.

naftiko: "0.5"
info:
  label: "CrowdStrike Host Detection Count"
  description: "Retrieves the number of active detections for a given hostname in CrowdStrike Falcon."
  tags:
    - security
    - crowdstrike
capability:
  exposes:
    - type: mcp
      namespace: security-ops
      port: 8080
      tools:
        - name: get-host-detections
          description: "Given a hostname, return the count of open CrowdStrike detections. Use for security posture reviews and endpoint compliance."
          inputParameters:
            - name: hostname
              in: body
              type: string
              description: "The hostname to query."
          call: "crowdstrike-detections.query-detections"
          with:
            filter: "device.hostname:'{{hostname}}'"
          outputParameters:
            - name: detection_count
              type: number
              mapping: "$.meta.pagination.total"
  consumes:
    - type: http
      namespace: crowdstrike-detections
      baseUri: "https://api.crowdstrike.com"
      authentication:
        type: bearer
        token: "$secrets.crowdstrike_token"
      resources:
        - name: detections
          path: "/detects/queries/detects/v1"
          operations:
            - name: query-detections
              method: GET

Pulls recent customer feedback from Snowflake, analyzes sentiment using Anthropic, and posts a weekly sentiment report to the product Slack channel.

naftiko: "0.5"
info:
  label: "Customer Sentiment Analysis Pipeline"
  description: "Pulls recent customer feedback from Snowflake, analyzes sentiment using Anthropic, and posts a weekly sentiment report to the product Slack channel."
  tags:
    - analytics
    - snowflake
    - anthropic
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: sentiment-ops
      port: 8080
      tools:
        - name: analyze-customer-sentiment
          description: "Given a product area and time range, pull feedback data, run AI sentiment analysis, and post results to Slack."
          inputParameters:
            - name: product_area
              in: body
              type: string
              description: "Product area (rides, eats, freight)."
            - name: days_back
              in: body
              type: number
              description: "Number of days of feedback to analyze."
          steps:
            - name: pull-feedback
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT feedback_text, rating FROM product.customer_feedback WHERE product_area='{{product_area}}' AND created_at>=DATEADD(day, -{{days_back}}, CURRENT_DATE()) LIMIT 100"
            - name: analyze-sentiment
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-3-5-sonnet-20241022"
                max_tokens: 1000
                messages: "[{\"role\": \"user\", \"content\": \"Analyze the sentiment of this customer feedback and provide a summary with key themes, sentiment breakdown, and top issues:\\n{{pull-feedback.data}}\"}]"
            - name: post-report
              type: call
              call: "slack.post-message"
              with:
                channel: "product-{{product_area}}"
                text: "Weekly Sentiment Report — {{product_area}} (last {{days_back}} days):\n{{analyze-sentiment.content}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a GDPR/CCPA deletion request is received, creates a Jira ticket for the privacy team, logs the request in Snowflake, and notifies the DPO via Slack.

naftiko: "0.5"
info:
  label: "Data Privacy Deletion Request"
  description: "When a GDPR/CCPA deletion request is received, creates a Jira ticket for the privacy team, logs the request in Snowflake, and notifies the DPO via Slack."
  tags:
    - privacy
    - compliance
    - jira
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: privacy-ops
      port: 8080
      tools:
        - name: process-deletion-request
          description: "Given a user ID and request type, create a privacy ticket, log the request, and notify the DPO."
          inputParameters:
            - name: user_id
              in: body
              type: string
              description: "The user ID requesting data deletion."
            - name: request_type
              in: body
              type: string
              description: "Type of request: GDPR_deletion, CCPA_deletion, data_export."
            - name: jurisdiction
              in: body
              type: string
              description: "The regulatory jurisdiction (EU, CA, etc.)."
          steps:
            - name: create-privacy-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PRIVACY"
                issuetype: "Task"
                summary: "{{request_type}} for user {{user_id}} ({{jurisdiction}})"
                priority: "High"
            - name: log-request
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO compliance.deletion_requests (user_id, request_type, jurisdiction, ticket_key, requested_at) VALUES ('{{user_id}}', '{{request_type}}', '{{jurisdiction}}', '{{create-privacy-ticket.key}}', CURRENT_TIMESTAMP())"
            - name: notify-dpo
              type: call
              call: "slack.post-message"
              with:
                channel: "privacy-team"
                text: "Data deletion request: {{request_type}} for user {{user_id}} ({{jurisdiction}}). Ticket: {{create-privacy-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Before a database migration, checks Snowflake for table sizes, verifies GitHub migration scripts exist, and posts a readiness report to the DBA Slack channel.

naftiko: "0.5"
info:
  label: "Database Migration Readiness Check"
  description: "Before a database migration, checks Snowflake for table sizes, verifies GitHub migration scripts exist, and posts a readiness report to the DBA Slack channel."
  tags:
    - data-engineering
    - snowflake
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: dba-ops
      port: 8080
      tools:
        - name: check-migration-readiness
          description: "Given a database and target schema, verify table sizes, check migration scripts, and report readiness."
          inputParameters:
            - name: database_name
              in: body
              type: string
              description: "The source database name."
            - name: schema_name
              in: body
              type: string
              description: "The schema to migrate."
            - name: migration_repo
              in: body
              type: string
              description: "GitHub repo containing migration scripts."
          steps:
            - name: check-table-sizes
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT table_name, row_count, bytes FROM {{database_name}}.information_schema.tables WHERE table_schema='{{schema_name}}'"
            - name: check-migration-scripts
              type: call
              call: "github.get-file-contents"
              with:
                repo: "{{migration_repo}}"
                path: "migrations/{{schema_name}}"
            - name: post-readiness
              type: call
              call: "slack.post-message"
              with:
                channel: "dba-team"
                text: "Migration readiness for {{database_name}}.{{schema_name}}:\nTables: {{check-table-sizes.data}}\nScripts available: {{check-migration-scripts.name}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: contents
          path: "/repos/uber/{{repo}}/contents/{{path}}"
          inputParameters:
            - name: repo
              in: path
            - name: path
              in: path
          operations:
            - name: get-file-contents
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog critical alert fires, creates a PagerDuty incident, opens a Jira P1 ticket, and posts the incident to the engineering war room Slack channel.

naftiko: "0.5"
info:
  label: "Datadog Alert to PagerDuty Escalation"
  description: "When a Datadog critical alert fires, creates a PagerDuty incident, opens a Jira P1 ticket, and posts the incident to the engineering war room Slack channel."
  tags:
    - incident-response
    - datadog
    - pagerduty
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: incident-escalation
      port: 8080
      tools:
        - name: escalate-datadog-alert
          description: "Given a Datadog alert ID and affected service, page the on-call via PagerDuty, create a P1 Jira ticket, and notify the war room."
          inputParameters:
            - name: monitor_name
              in: body
              type: string
              description: "The Datadog monitor name."
            - name: affected_service
              in: body
              type: string
              description: "The affected service name."
            - name: alert_url
              in: body
              type: string
              description: "URL to the Datadog alert."
          steps:
            - name: page-oncall
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "Critical: {{monitor_name}} — {{affected_service}}"
                service_id: "{{affected_service}}_SRE"
                body: "Datadog alert: {{alert_url}}"
            - name: create-p1-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "INC"
                issuetype: "Bug"
                summary: "[P1] {{monitor_name}} — {{affected_service}}"
                priority: "Highest"
            - name: notify-war-room
              type: call
              call: "slack.post-message"
              with:
                channel: "eng-war-room"
                text: "P1 INCIDENT: {{monitor_name}} | Service: {{affected_service}} | PD: {{page-oncall.incident.id}} | Jira: {{create-p1-ticket.key}} | Alert: {{alert_url}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Datadog APM for the p99 latency of a given service over the last hour.

naftiko: "0.5"
info:
  label: "Datadog APM Service Latency Check"
  description: "Queries Datadog APM for the p99 latency of a given service over the last hour."
  tags:
    - observability
    - datadog
    - performance
capability:
  exposes:
    - type: mcp
      namespace: apm-insights
      port: 8080
      tools:
        - name: get-service-latency
          description: "Given a Datadog service name, return p99 latency for the last hour. Use for SLO tracking and performance reviews."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The Datadog APM service name."
          call: "datadog-apm.query-timeseries"
          with:
            query: "avg:trace.http.request.duration.by_service_95p{service:{{service_name}}}"
          outputParameters:
            - name: p99_latency_ms
              type: number
              mapping: "$.series[0].pointlist[-1][1]"
  consumes:
    - type: http
      namespace: datadog-apm
      baseUri: "https://api.datadoghq.com/api/v1"
      authentication:
        type: apikey
        key: "DD-API-KEY"
        value: "$secrets.datadog_api_key"
        placement: header
      resources:
        - name: timeseries
          path: "/query"
          operations:
            - name: query-timeseries
              method: GET

Searches Datadog logs for a given query string and returns matching log entries.

naftiko: "0.5"
info:
  label: "Datadog Log Search"
  description: "Searches Datadog logs for a given query string and returns matching log entries."
  tags:
    - observability
    - datadog
    - logging
capability:
  exposes:
    - type: mcp
      namespace: log-ops
      port: 8080
      tools:
        - name: search-logs
          description: "Given a Datadog log query, return matching log entries. Use for incident investigation and debugging."
          inputParameters:
            - name: query
              in: body
              type: string
              description: "The Datadog log search query."
          call: "datadog-logs.search-logs"
          with:
            query: "{{query}}"
          outputParameters:
            - name: log_count
              type: number
              mapping: "$.meta.page.total_count"
  consumes:
    - type: http
      namespace: datadog-logs
      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 the current health status and recent alert history for a Datadog monitor by ID, for use in incident triage and engineering war rooms.

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

When a design document is submitted for review, creates a Jira review ticket, posts the document link to the architecture review Slack channel, and updates the Confluence review tracker.

naftiko: "0.5"
info:
  label: "Design Review Scheduling Workflow"
  description: "When a design document is submitted for review, creates a Jira review ticket, posts the document link to the architecture review Slack channel, and updates the Confluence review tracker."
  tags:
    - architecture
    - jira
    - slack
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: design-review
      port: 8080
      tools:
        - name: schedule-design-review
          description: "Given a design document and author, create a review ticket, notify reviewers, and update the tracker."
          inputParameters:
            - name: doc_title
              in: body
              type: string
              description: "Title of the design document."
            - name: doc_url
              in: body
              type: string
              description: "URL to the design document."
            - name: author
              in: body
              type: string
              description: "Author of the design document."
            - name: review_team
              in: body
              type: string
              description: "The team that should review."
          steps:
            - name: create-review-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ARCH"
                issuetype: "Task"
                summary: "Design review: {{doc_title}} by {{author}}"
                description: "Document: {{doc_url}}"
            - name: notify-reviewers
              type: call
              call: "slack.post-message"
              with:
                channel: "architecture-reviews"
                text: "New design review: {{doc_title}} by {{author}}. Doc: {{doc_url}}. Jira: {{create-review-ticket.key}}. Reviewers: {{review_team}}"
            - name: update-tracker
              type: call
              call: "confluence.create-page"
              with:
                spaceKey: "ARCH"
                title: "Review: {{doc_title}}"
                body: "Author: {{author}}\nDoc: {{doc_url}}\nJira: {{create-review-ticket.key}}\nStatus: Pending"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Distributes developer experience surveys, collects responses in Snowflake, summarizes results with Anthropic AI, and posts insights to the platform engineering Slack channel.

naftiko: "0.5"
info:
  label: "Developer Experience Survey Orchestrator"
  description: "Distributes developer experience surveys, collects responses in Snowflake, summarizes results with Anthropic AI, and posts insights to the platform engineering Slack channel."
  tags:
    - developer-experience
    - snowflake
    - anthropic
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: devex-ops
      port: 8080
      tools:
        - name: analyze-devex-survey
          description: "Given a survey period, query responses from Snowflake, summarize with AI, and post insights."
          inputParameters:
            - name: survey_period
              in: body
              type: string
              description: "The survey period (e.g., Q1-2026)."
          steps:
            - name: query-responses
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT question, AVG(score) as avg_score, COUNT(*) as responses FROM devex.survey_responses WHERE period='{{survey_period}}' GROUP BY question"
            - name: summarize-results
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-3-5-sonnet-20241022"
                max_tokens: 1000
                messages: "[{\"role\": \"user\", \"content\": \"Analyze these developer experience survey results and identify top 3 areas for improvement:\\n{{query-responses.data}}\"}]"
            - name: post-insights
              type: call
              call: "slack.post-message"
              with:
                channel: "platform-engineering"
                text: "DevEx Survey Results — {{survey_period}}:\n{{summarize-results.content}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a DNS change is requested, creates a Jira change request ticket, notifies the network team via Slack, and logs the change in Snowflake for audit.

naftiko: "0.5"
info:
  label: "DNS Change Approval Workflow"
  description: "When a DNS change is requested, creates a Jira change request ticket, notifies the network team via Slack, and logs the change in Snowflake for audit."
  tags:
    - infrastructure
    - networking
    - jira
    - slack
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: dns-ops
      port: 8080
      tools:
        - name: request-dns-change
          description: "Given DNS change details, create a change request, notify the network team, and log for audit."
          inputParameters:
            - name: domain
              in: body
              type: string
              description: "The domain name."
            - name: record_type
              in: body
              type: string
              description: "DNS record type (A, CNAME, etc.)."
            - name: new_value
              in: body
              type: string
              description: "The new DNS record value."
            - name: requester
              in: body
              type: string
              description: "The person requesting the change."
          steps:
            - name: create-change-request
              type: call
              call: "jira.create-issue"
              with:
                project_key: "NET"
                issuetype: "Task"
                summary: "DNS change: {{domain}} {{record_type}} -> {{new_value}}"
                description: "Requested by: {{requester}}"
            - name: notify-network-team
              type: call
              call: "slack.post-message"
              with:
                channel: "network-ops"
                text: "DNS change request: {{domain}} {{record_type}} -> {{new_value}}. Requester: {{requester}}. Ticket: {{create-change-request.key}}"
            - name: log-change
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO infra.dns_changes (domain, record_type, new_value, requester, ticket_key, requested_at) VALUES ('{{domain}}', '{{record_type}}', '{{new_value}}', '{{requester}}', '{{create-change-request.key}}', CURRENT_TIMESTAMP())"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

When a DocuSign contract is completed, updates the Salesforce opportunity, creates a Jira implementation ticket, and notifies the deal team via Slack.

naftiko: "0.5"
info:
  label: "DocuSign Contract Completion Handler"
  description: "When a DocuSign contract is completed, updates the Salesforce opportunity, creates a Jira implementation ticket, and notifies the deal team via Slack."
  tags:
    - legal
    - docusign
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: contract-ops
      port: 8080
      tools:
        - name: handle-contract-completion
          description: "Given a DocuSign envelope ID and deal details, update Salesforce, create implementation tickets, and notify the team."
          inputParameters:
            - name: envelope_id
              in: body
              type: string
              description: "The DocuSign envelope ID."
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID."
            - name: account_name
              in: body
              type: string
              description: "The account name."
          steps:
            - name: update-opportunity
              type: call
              call: "salesforce.update-opportunity"
              with:
                opportunity_id: "{{opportunity_id}}"
                StageName: "Closed Won"
                Contract_Signed__c: true
            - name: create-implementation-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "IMPL"
                issuetype: "Epic"
                summary: "Implementation: {{account_name}} — Contract signed"
            - name: notify-deal-team
              type: call
              call: "slack.post-message"
              with:
                channel: "deals-closed"
                text: "Contract signed! {{account_name}} (DocuSign: {{envelope_id}}). Implementation: {{create-implementation-ticket.key}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.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: update-opportunity
              method: PATCH
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new driver applicant completes registration, initiates a background check, creates a Workday contingent worker record, and notifies the driver ops team via Slack.

naftiko: "0.5"
info:
  label: "Driver Background Check Orchestrator"
  description: "When a new driver applicant completes registration, initiates a background check, creates a Workday contingent worker record, and notifies the driver ops team via Slack."
  tags:
    - driver-ops
    - workday
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: driver-onboarding
      port: 8080
      tools:
        - name: initiate-driver-background-check
          description: "Given driver applicant details, create a Workday contingent worker record, log background check initiation in Jira, and notify driver ops."
          inputParameters:
            - name: applicant_name
              in: body
              type: string
              description: "Full name of the driver applicant."
            - name: applicant_email
              in: body
              type: string
              description: "Email address of the driver applicant."
            - name: market
              in: body
              type: string
              description: "The market/city the driver will operate in."
          steps:
            - name: create-workday-record
              type: call
              call: "workday.create-contingent-worker"
              with:
                name: "{{applicant_name}}"
                email: "{{applicant_email}}"
                worker_type: "driver_applicant"
            - name: create-tracking-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DRIVER"
                issuetype: "Task"
                summary: "Background check: {{applicant_name}} — {{market}}"
            - name: notify-driver-ops
              type: call
              call: "slack.post-message"
              with:
                channel: "driver-ops-{{market}}"
                text: "New driver applicant {{applicant_name}} ({{applicant_email}}) background check initiated. Tracking: {{create-tracking-ticket.key}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: contingent-workers
          path: "/workers"
          operations:
            - name: create-contingent-worker
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a driver submits an earnings dispute, queries trip earnings from Snowflake, creates a Jira support ticket, and notifies driver operations via Slack.

naftiko: "0.5"
info:
  label: "Driver Earnings Dispute Handler"
  description: "When a driver submits an earnings dispute, queries trip earnings from Snowflake, creates a Jira support ticket, and notifies driver operations via Slack."
  tags:
    - driver-ops
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: driver-earnings
      port: 8080
      tools:
        - name: handle-earnings-dispute
          description: "Given a driver ID, trip ID, and dispute details, pull earnings data, create a support ticket, and notify driver ops."
          inputParameters:
            - name: driver_id
              in: body
              type: string
              description: "The driver partner ID."
            - name: trip_id
              in: body
              type: string
              description: "The trip ID in question."
            - name: dispute_reason
              in: body
              type: string
              description: "Reason for earnings dispute."
          steps:
            - name: query-earnings
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT fare, earnings, tips, adjustments FROM driver.trip_earnings WHERE driver_id='{{driver_id}}' AND trip_id='{{trip_id}}'"
            - name: create-dispute-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DRIVER"
                issuetype: "Task"
                summary: "Earnings dispute: Driver {{driver_id}} — Trip {{trip_id}}"
                description: "Reason: {{dispute_reason}}\nEarnings data: {{query-earnings.data}}"
            - name: notify-driver-ops
              type: call
              call: "slack.post-message"
              with:
                channel: "driver-operations"
                text: "Earnings dispute: Driver {{driver_id}}, Trip {{trip_id}}. Reason: {{dispute_reason}}. Ticket: {{create-dispute-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a fraud detection system flags a driver partner account, creates a ServiceNow fraud investigation ticket, notifies the trust and safety team via Slack, and logs the event in Datadog.

naftiko: "0.5"
info:
  label: "Driver Partner Fraud Alert Escalation"
  description: "When a fraud detection system flags a driver partner account, creates a ServiceNow fraud investigation ticket, notifies the trust and safety team via Slack, and logs the event in Datadog."
  tags:
    - trust-safety
    - fraud
    - servicenow
    - slack
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: fraud-ops
      port: 8080
      tools:
        - name: escalate-fraud-alert
          description: "Given a driver partner ID, fraud type, and confidence score, create a ServiceNow investigation ticket, notify the Trust and Safety team via Slack, and post a Datadog security event."
          inputParameters:
            - name: driver_id
              in: body
              type: string
              description: "The driver partner ID flagged for potential fraud."
            - name: fraud_type
              in: body
              type: string
              description: "Type of fraud detected (e.g., GPS spoofing, account takeover, trip manipulation)."
            - name: confidence_score
              in: body
              type: number
              description: "Fraud detection confidence score (0.0 to 1.0)."
          steps:
            - name: create-fraud-ticket
              type: call
              call: "servicenow-fraud.create-incident"
              with:
                short_description: "Fraud alert: Driver {{driver_id}} — {{fraud_type}}"
                category: "trust_safety"
                priority: "2"
                description: "Confidence score: {{confidence_score}}"
            - name: notify-trust-safety
              type: call
              call: "slack-fraud.post-message"
              with:
                channel: "trust-safety-alerts"
                text: "Fraud Alert: Driver {{driver_id}} | Type: {{fraud_type}} | Confidence: {{confidence_score}} | ServiceNow: {{create-fraud-ticket.number}}"
            - name: log-security-event
              type: call
              call: "datadog-fraud.create-event"
              with:
                title: "Fraud Detection: {{fraud_type}} — Driver {{driver_id}}"
                text: "Confidence: {{confidence_score}}. ServiceNow ticket: {{create-fraud-ticket.number}}"
                alert_type: "warning"
  consumes:
    - type: http
      namespace: servicenow-fraud
      baseUri: "https://uber.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-fraud
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: datadog-fraud
      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

When a critical safety incident is reported on the Uber platform, creates a ServiceNow safety incident ticket, escalates to the safety operations team, and notifies legal and compliance via Slack.

naftiko: "0.5"
info:
  label: "Driver Safety Incident Escalation"
  description: "When a critical safety incident is reported on the Uber platform, creates a ServiceNow safety incident ticket, escalates to the safety operations team, and notifies legal and compliance via Slack."
  tags:
    - safety
    - operations
    - servicenow
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: safety-ops
      port: 8080
      tools:
        - name: escalate-safety-incident
          description: "Given a safety incident ID, trip ID, and severity, create a ServiceNow safety ticket, escalate to the safety operations and legal teams via Slack."
          inputParameters:
            - name: incident_id
              in: body
              type: string
              description: "The internal safety incident ID."
            - name: trip_id
              in: body
              type: string
              description: "The Uber trip ID associated with the safety incident."
            - name: severity
              in: body
              type: string
              description: "Safety incident severity: critical, high, medium."
            - name: incident_description
              in: body
              type: string
              description: "Brief description of the safety incident."
          steps:
            - name: create-safety-ticket
              type: call
              call: "servicenow.create-incident"
              with:
                short_description: "Safety Incident {{incident_id}}: {{severity}} — Trip {{trip_id}}"
                category: "safety"
                priority: "1"
                description: "{{incident_description}}"
            - name: notify-safety-ops
              type: call
              call: "slack-safety.post-message"
              with:
                channel: "safety-operations"
                text: "SAFETY INCIDENT: {{incident_id}} | Trip: {{trip_id}} | Severity: {{severity}} | ServiceNow: {{create-safety-ticket.number}} | Details: {{incident_description}}"
            - name: notify-legal
              type: call
              call: "slack-safety.post-message"
              with:
                channel: "legal-escalations"
                text: "Safety incident flagged for legal review: {{incident_id}} | Severity: {{severity}} | ServiceNow: {{create-safety-ticket.number}}"
  consumes:
    - type: http
      namespace: servicenow
      baseUri: "https://uber.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: incidents
          path: "/table/incident"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: slack-safety
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Datadog anomaly is detected in surge pricing metrics, queries Snowflake for pricing data, creates a Jira investigation ticket, and alerts the pricing team via Slack.

naftiko: "0.5"
info:
  label: "Dynamic Pricing Anomaly Alert"
  description: "When a Datadog anomaly is detected in surge pricing metrics, queries Snowflake for pricing data, creates a Jira investigation ticket, and alerts the pricing team via Slack."
  tags:
    - pricing
    - datadog
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: pricing-ops
      port: 8080
      tools:
        - name: investigate-pricing-anomaly
          description: "Given a market and anomaly details, query pricing data, create an investigation ticket, and notify the pricing team."
          inputParameters:
            - name: market
              in: body
              type: string
              description: "The market/city where the anomaly was detected."
            - name: anomaly_type
              in: body
              type: string
              description: "Type of anomaly (e.g., surge_spike, multiplier_floor)."
            - name: alert_url
              in: body
              type: string
              description: "URL to the Datadog alert."
          steps:
            - name: query-pricing-data
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT avg(surge_multiplier), max(surge_multiplier) FROM pricing.surge_events WHERE market='{{market}}' AND event_time>=DATEADD(hour, -1, CURRENT_TIMESTAMP())"
            - name: create-investigation
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PRICING"
                issuetype: "Bug"
                summary: "Pricing anomaly: {{anomaly_type}} in {{market}}"
                description: "Alert: {{alert_url}}\nData: {{query-pricing-data.data}}"
            - name: alert-pricing-team
              type: call
              call: "slack.post-message"
              with:
                channel: "pricing-alerts"
                text: "Pricing anomaly in {{market}}: {{anomaly_type}}. Jira: {{create-investigation.key}}. Data: avg={{query-pricing-data.data[0][0]}}, max={{query-pricing-data.data[0][1]}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When order volume drops unexpectedly in a market, queries Snowflake for order metrics, creates a Jira investigation ticket, and alerts the Eats operations team via Slack.

naftiko: "0.5"
info:
  label: "Eats Order Volume Anomaly Handler"
  description: "When order volume drops unexpectedly in a market, queries Snowflake for order metrics, creates a Jira investigation ticket, and alerts the Eats operations team via Slack."
  tags:
    - eats
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eats-ops
      port: 8080
      tools:
        - name: investigate-order-anomaly
          description: "Given a market and anomaly details, query order data, create an investigation, and notify the Eats team."
          inputParameters:
            - name: market
              in: body
              type: string
              description: "The market/city."
            - name: drop_percentage
              in: body
              type: number
              description: "Percentage drop in order volume."
          steps:
            - name: query-order-data
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT hour, order_count, avg_order_value FROM eats.order_metrics WHERE market='{{market}}' AND date=CURRENT_DATE() ORDER BY hour"
            - name: create-investigation
              type: call
              call: "jira.create-issue"
              with:
                project_key: "EATS"
                issuetype: "Bug"
                summary: "Order volume drop in {{market}}: {{drop_percentage}}%"
            - name: alert-eats-ops
              type: call
              call: "slack.post-message"
              with:
                channel: "eats-operations"
                text: "Order volume anomaly: {{market}} down {{drop_percentage}}%. Data: {{query-order-data.data}}. Jira: {{create-investigation.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new restaurant partner signs up, creates a Salesforce account, provisions a Jira onboarding project, and sends a welcome email via SendGrid.

naftiko: "0.5"
info:
  label: "Eats Restaurant Onboarding Workflow"
  description: "When a new restaurant partner signs up, creates a Salesforce account, provisions a Jira onboarding project, and sends a welcome email via SendGrid."
  tags:
    - eats
    - salesforce
    - jira
    - sendgrid
    - onboarding
capability:
  exposes:
    - type: mcp
      namespace: restaurant-ops
      port: 8080
      tools:
        - name: onboard-restaurant-partner
          description: "Given restaurant details, create a Salesforce account, Jira onboarding project, and send a welcome email."
          inputParameters:
            - name: restaurant_name
              in: body
              type: string
              description: "Name of the restaurant."
            - name: contact_email
              in: body
              type: string
              description: "Primary contact email."
            - name: city
              in: body
              type: string
              description: "City where the restaurant operates."
          steps:
            - name: create-sf-account
              type: call
              call: "salesforce.create-account"
              with:
                Name: "{{restaurant_name}}"
                Type: "Restaurant Partner"
                BillingCity: "{{city}}"
            - name: create-onboarding-project
              type: call
              call: "jira.create-issue"
              with:
                project_key: "EATS"
                issuetype: "Epic"
                summary: "Onboarding: {{restaurant_name}} — {{city}}"
            - name: send-welcome-email
              type: call
              call: "sendgrid.send-email"
              with:
                to: "{{contact_email}}"
                subject: "Welcome to Uber Eats, {{restaurant_name}}!"
                body: "Your onboarding has begun. Tracking: {{create-onboarding-project.key}}. Your Salesforce ID: {{create-sf-account.id}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: accounts
          path: "/sobjects/Account"
          operations:
            - name: create-account
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: sendgrid
      baseUri: "https://api.sendgrid.com/v3"
      authentication:
        type: bearer
        token: "$secrets.sendgrid_api_key"
      resources:
        - name: mail
          path: "/mail/send"
          operations:
            - name: send-email
              method: POST

Queries employee pulse survey scores from Snowflake, summarizes trends with Anthropic AI, and posts insights to the people team Slack channel.

naftiko: "0.5"
info:
  label: "Employee Satisfaction Pulse Check"
  description: "Queries employee pulse survey scores from Snowflake, summarizes trends with Anthropic AI, and posts insights to the people team Slack channel."
  tags:
    - hr
    - snowflake
    - anthropic
    - slack
    - ai
capability:
  exposes:
    - type: mcp
      namespace: people-ops
      port: 8080
      tools:
        - name: analyze-pulse-survey
          description: "Given a survey month, pull scores, summarize with AI, and share insights."
          inputParameters:
            - name: survey_month
              in: body
              type: string
              description: "The survey month (e.g., 2026-03)."
          steps:
            - name: query-scores
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT department, AVG(score) as avg_score, COUNT(*) as responses FROM hr.pulse_surveys WHERE survey_month='{{survey_month}}' GROUP BY department ORDER BY avg_score"
            - name: summarize-trends
              type: call
              call: "anthropic.create-message"
              with:
                model: "claude-3-5-sonnet-20241022"
                max_tokens: 800
                messages: "[{\"role\": \"user\", \"content\": \"Analyze these employee satisfaction scores by department and identify trends and areas of concern:\\n{{query-scores.data}}\"}]"
            - name: share-insights
              type: call
              call: "slack.post-message"
              with:
                channel: "people-team"
                text: "Pulse survey insights for {{survey_month}}:\n{{summarize-trends.content}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: anthropic
      baseUri: "https://api.anthropic.com/v1"
      authentication:
        type: apikey
        key: "x-api-key"
        value: "$secrets.anthropic_api_key"
        placement: header
      resources:
        - name: messages
          path: "/messages"
          operations:
            - name: create-message
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new software engineer joins Uber, creates a Jira onboarding epic, provisions GitHub org access, provisions Okta account, and sends a Slack welcome to the team channel.

naftiko: "0.5"
info:
  label: "Engineer Onboarding Orchestrator"
  description: "When a new software engineer joins Uber, creates a Jira onboarding epic, provisions GitHub org access, provisions Okta account, and sends a Slack welcome to the team channel."
  tags:
    - hr
    - onboarding
    - workday
    - jira
    - github
    - okta
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-onboarding
      port: 8080
      tools:
        - name: trigger-engineer-onboarding
          description: "Given a Workday employee ID, GitHub username, and team assignment, orchestrate full engineering onboarding across Jira, GitHub, Okta, and Slack."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID for the new engineer."
            - name: github_username
              in: body
              type: string
              description: "New hire's GitHub username for org provisioning."
            - name: team_name
              in: body
              type: string
              description: "The engineering team (e.g., Rides, Eats, Platform, Maps)."
            - name: start_date
              in: body
              type: string
              description: "Start date in YYYY-MM-DD format."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: create-onboarding-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Epic"
                summary: "Onboarding: {{get-employee.full_name}} - {{team_name}} - {{start_date}}"
            - name: provision-github
              type: call
              call: "github.add-org-member"
              with:
                username: "{{github_username}}"
                role: "member"
            - name: provision-okta
              type: call
              call: "okta.create-user"
              with:
                email: "{{get-employee.work_email}}"
                firstName: "{{get-employee.first_name}}"
                lastName: "{{get-employee.last_name}}"
            - name: welcome-slack
              type: call
              call: "slack.post-message"
              with:
                channel: "{{team_name}}-engineering"
                text: "Welcome {{get-employee.first_name}} {{get-employee.last_name}} to the {{team_name}} team! They start {{start_date}}. Onboarding: {{create-onboarding-epic.key}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/uber/memberships/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: add-org-member
              method: PUT
    - type: http
      namespace: okta
      baseUri: "https://uber.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users"
          operations:
            - name: create-user
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an engineering blog post draft is approved, creates a GitHub PR for the blog repo, notifies the comms team via Slack, and shares on LinkedIn.

naftiko: "0.5"
info:
  label: "Engineering Blog Publication Workflow"
  description: "When an engineering blog post draft is approved, creates a GitHub PR for the blog repo, notifies the comms team via Slack, and shares on LinkedIn."
  tags:
    - communications
    - github
    - slack
    - linkedin
capability:
  exposes:
    - type: mcp
      namespace: eng-comms
      port: 8080
      tools:
        - name: publish-blog-post
          description: "Given a blog post title and author, create a GitHub PR for publication and notify the comms team."
          inputParameters:
            - name: post_title
              in: body
              type: string
              description: "Title of the blog post."
            - name: author
              in: body
              type: string
              description: "Author's name."
            - name: github_branch
              in: body
              type: string
              description: "The branch containing the blog post."
          steps:
            - name: create-blog-pr
              type: call
              call: "github.create-pull-request"
              with:
                repo: "uber-engineering-blog"
                title: "Publish: {{post_title}} by {{author}}"
                head: "{{github_branch}}"
                base: "main"
            - name: notify-comms
              type: call
              call: "slack.post-message"
              with:
                channel: "eng-communications"
                text: "Blog post ready for review: {{post_title}} by {{author}}. PR: {{create-blog-pr.html_url}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pulls
          path: "/repos/uber/{{repo}}/pulls"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: create-pull-request
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an executive requisition is opened, creates a Salesforce recruiting campaign, posts to LinkedIn, and notifies the executive recruiting Slack channel.

naftiko: "0.5"
info:
  label: "Executive Talent Acquisition Pipeline"
  description: "When an executive requisition is opened, creates a Salesforce recruiting campaign, posts to LinkedIn, and notifies the executive recruiting Slack channel."
  tags:
    - recruiting
    - salesforce
    - linkedin
    - slack
capability:
  exposes:
    - type: mcp
      namespace: exec-recruiting
      port: 8080
      tools:
        - name: launch-exec-search
          description: "Given a role title and hiring manager, create a Salesforce recruiting campaign, post to LinkedIn, and notify the team."
          inputParameters:
            - name: role_title
              in: body
              type: string
              description: "The executive role title."
            - name: hiring_manager
              in: body
              type: string
              description: "The hiring manager's name."
            - name: level
              in: body
              type: string
              description: "The role level (VP, SVP, C-suite)."
          steps:
            - name: create-campaign
              type: call
              call: "salesforce.create-campaign"
              with:
                Name: "Exec search: {{role_title}} ({{level}})"
                Type: "Executive Recruiting"
            - name: notify-recruiting
              type: call
              call: "slack.post-message"
              with:
                channel: "executive-recruiting"
                text: "New executive search: {{role_title}} ({{level}}). Hiring manager: {{hiring_manager}}. Campaign: {{create-campaign.id}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.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: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a feature flag is enabled for a new percentage of users, logs the rollout in Snowflake, creates a Jira tracking ticket, and notifies the product team via Slack.

naftiko: "0.5"
info:
  label: "Feature Flag Rollout Tracker"
  description: "When a feature flag is enabled for a new percentage of users, logs the rollout in Snowflake, creates a Jira tracking ticket, and notifies the product team via Slack."
  tags:
    - engineering
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: feature-ops
      port: 8080
      tools:
        - name: track-flag-rollout
          description: "Given a feature flag name and rollout percentage, log the change, create a tracking ticket, and notify the team."
          inputParameters:
            - name: flag_name
              in: body
              type: string
              description: "The feature flag name."
            - name: rollout_pct
              in: body
              type: number
              description: "New rollout percentage."
            - name: team_name
              in: body
              type: string
              description: "Owning team name."
          steps:
            - name: log-rollout
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO eng.feature_rollouts (flag_name, rollout_pct, team, changed_at) VALUES ('{{flag_name}}', {{rollout_pct}}, '{{team_name}}', CURRENT_TIMESTAMP())"
            - name: create-tracking-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Task"
                summary: "Feature rollout: {{flag_name}} at {{rollout_pct}}%"
            - name: notify-team
              type: call
              call: "slack.post-message"
              with:
                channel: "{{team_name}}-engineering"
                text: "Feature flag {{flag_name}} rolled out to {{rollout_pct}}% of users. Tracking: {{create-tracking-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a freight shipment status changes, updates the Salesforce opportunity, notifies the shipper via Slack, and logs the event in Snowflake.

naftiko: "0.5"
info:
  label: "Freight Shipment Status Tracker"
  description: "When a freight shipment status changes, updates the Salesforce opportunity, notifies the shipper via Slack, and logs the event in Snowflake."
  tags:
    - freight
    - salesforce
    - slack
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: freight-ops
      port: 8080
      tools:
        - name: track-shipment-status-change
          description: "Given a shipment ID and new status, update Salesforce, notify the shipper on Slack, and log in Snowflake."
          inputParameters:
            - name: shipment_id
              in: body
              type: string
              description: "The freight shipment ID."
            - name: new_status
              in: body
              type: string
              description: "New shipment status (e.g., in_transit, delivered, delayed)."
            - name: shipper_channel
              in: body
              type: string
              description: "The Slack channel for the shipper."
          steps:
            - name: update-salesforce
              type: call
              call: "salesforce.update-opportunity"
              with:
                opportunity_id: "{{shipment_id}}"
                StageName: "{{new_status}}"
            - name: notify-shipper
              type: call
              call: "slack.post-message"
              with:
                channel: "{{shipper_channel}}"
                text: "Shipment {{shipment_id}} status changed to {{new_status}}"
            - name: log-event
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO freight.shipment_events (shipment_id, status, event_time) VALUES ('{{shipment_id}}', '{{new_status}}', CURRENT_TIMESTAMP())"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.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: update-opportunity
              method: PATCH
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

Retrieves the latest run status for a specific GitHub Actions workflow.

naftiko: "0.5"
info:
  label: "GitHub Actions Workflow Status"
  description: "Retrieves the latest run status for a specific GitHub Actions workflow."
  tags:
    - cicd
    - github
    - github-actions
capability:
  exposes:
    - type: mcp
      namespace: cicd-ops
      port: 8080
      tools:
        - name: get-workflow-status
          description: "Given a repo and workflow file name, return the latest run status and conclusion. Use for deployment readiness checks."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
            - name: workflow_file
              in: body
              type: string
              description: "The workflow file name (e.g., ci.yml)."
          call: "github-actions.list-workflow-runs"
          with:
            repo: "{{repo_name}}"
            workflow_id: "{{workflow_file}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.workflow_runs[0].status"
            - name: conclusion
              type: string
              mapping: "$.workflow_runs[0].conclusion"
  consumes:
    - type: http
      namespace: github-actions
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: workflow-runs
          path: "/repos/uber/{{repo}}/actions/workflows/{{workflow_id}}/runs"
          inputParameters:
            - name: repo
              in: path
            - name: workflow_id
              in: path
          operations:
            - name: list-workflow-runs
              method: GET

Retrieves the branch protection rules for a given GitHub repository's main branch.

naftiko: "0.5"
info:
  label: "GitHub Branch Protection Audit"
  description: "Retrieves the branch protection rules for a given GitHub repository's main branch."
  tags:
    - security
    - github
capability:
  exposes:
    - type: mcp
      namespace: repo-security
      port: 8080
      tools:
        - name: get-branch-protection
          description: "Given a repo name, return the branch protection rules for main. Use for security compliance audits."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
          call: "github-repos.get-branch-protection"
          with:
            repo: "{{repo_name}}"
          outputParameters:
            - name: required_reviews
              type: number
              mapping: "$.required_pull_request_reviews.required_approving_review_count"
            - name: enforce_admins
              type: boolean
              mapping: "$.enforce_admins.enabled"
  consumes:
    - type: http
      namespace: github-repos
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: branch-protection
          path: "/repos/uber/{{repo}}/branches/main/protection"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: get-branch-protection
              method: GET

Retrieves open Dependabot alerts for a GitHub repository, creates Jira security tickets for critical vulnerabilities, and posts a remediation summary to the security Slack channel.

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

When a pull request modifying security-sensitive code is opened, creates a Jira security review task, assigns it to the security team, and notifies them via Slack.

naftiko: "0.5"
info:
  label: "GitHub Pull Request Security Review"
  description: "When a pull request modifying security-sensitive code is opened, creates a Jira security review task, assigns it to the security team, and notifies them via Slack."
  tags:
    - security
    - devops
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: security-review
      port: 8080
      tools:
        - name: request-security-review
          description: "Given a GitHub PR number and repository touching security-sensitive files, create a Jira security review task, assign to the AppSec team, and notify them in Slack."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
            - name: pr_number
              in: body
              type: integer
              description: "The pull request number requiring security review."
            - name: sensitive_files
              in: body
              type: string
              description: "Comma-separated list of security-sensitive files modified in the PR."
          steps:
            - name: get-pr-details
              type: call
              call: "github-security.get-pull-request"
              with:
                repo: "{{repo_name}}"
                pull_number: "{{pr_number}}"
            - name: create-security-task
              type: call
              call: "jira-security.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Task"
                summary: "Security review: {{repo_name}} PR #{{pr_number}} — {{get-pr-details.title}}"
                description: "Sensitive files: {{sensitive_files}}\nPR: {{get-pr-details.html_url}}"
            - name: notify-appsec
              type: call
              call: "slack-security.post-message"
              with:
                channel: "appsec-reviews"
                text: "Security review needed: {{repo_name}} PR #{{pr_number}} | Files: {{sensitive_files}} | PR: {{get-pr-details.html_url}} | Jira: {{create-security-task.key}}"
  consumes:
    - type: http
      namespace: github-security
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: pull-requests
          path: "/repos/{{repo}}/pulls/{{pull_number}}"
          inputParameters:
            - name: repo
              in: path
            - name: pull_number
              in: path
          operations:
            - name: get-pull-request
              method: GET
    - type: http
      namespace: jira-security
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-security
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new GitHub release is published, posts the release notes to the relevant engineering Slack channel and creates a Confluence changelog entry.

naftiko: "0.5"
info:
  label: "GitHub Release to Slack Announcement"
  description: "When a new GitHub release is published, posts the release notes to the relevant engineering Slack channel and creates a Confluence changelog entry."
  tags:
    - engineering
    - github
    - slack
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: release-comms
      port: 8080
      tools:
        - name: announce-release
          description: "Given a GitHub repo and release tag, fetch release notes, post to Slack, and create a Confluence changelog page."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
            - name: release_tag
              in: body
              type: string
              description: "The release tag (e.g., v2.1.0)."
          steps:
            - name: get-release
              type: call
              call: "github.get-release-by-tag"
              with:
                repo: "{{repo_name}}"
                tag: "{{release_tag}}"
            - name: post-to-slack
              type: call
              call: "slack.post-message"
              with:
                channel: "releases-{{repo_name}}"
                text: "New release {{release_tag}} for {{repo_name}}:\n{{get-release.body}}"
            - name: create-changelog
              type: call
              call: "confluence.create-page"
              with:
                spaceKey: "ENG"
                title: "Release {{release_tag}} — {{repo_name}}"
                body: "{{get-release.body}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: releases
          path: "/repos/uber/{{repo}}/releases/tags/{{tag}}"
          inputParameters:
            - name: repo
              in: path
            - name: tag
              in: path
          operations:
            - name: get-release-by-tag
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST

Retrieves the programming language distribution for a given GitHub repository within the Uber organization.

naftiko: "0.5"
info:
  label: "GitHub Repo Language Breakdown"
  description: "Retrieves the programming language distribution for a given GitHub repository within the Uber organization."
  tags:
    - engineering
    - github
capability:
  exposes:
    - type: mcp
      namespace: eng-insights
      port: 8080
      tools:
        - name: get-repo-languages
          description: "Given a GitHub repository name under the Uber org, return the byte-count breakdown by programming language. Use for tech stack audits and migration planning."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The repository name within the uber org."
          call: "github-repos.get-languages"
          with:
            repo: "{{repo_name}}"
          outputParameters:
            - name: languages
              type: object
              mapping: "$"
  consumes:
    - type: http
      namespace: github-repos
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: languages
          path: "/repos/uber/{{repo}}/languages"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: get-languages
              method: GET

When a GitHub repository secret approaches its rotation deadline, creates a Jira ticket for the owning team and posts a reminder to the security Slack channel.

naftiko: "0.5"
info:
  label: "GitHub Secret Rotation Reminder"
  description: "When a GitHub repository secret approaches its rotation deadline, creates a Jira ticket for the owning team and posts a reminder to the security Slack channel."
  tags:
    - security
    - github
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: secret-mgmt
      port: 8080
      tools:
        - name: remind-secret-rotation
          description: "Given a repo and secret name nearing expiration, create a rotation ticket and notify security."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
            - name: secret_name
              in: body
              type: string
              description: "The secret name requiring rotation."
            - name: expiration_date
              in: body
              type: string
              description: "The secret expiration date."
          steps:
            - name: create-rotation-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Task"
                summary: "Secret rotation required: {{secret_name}} in {{repo_name}} by {{expiration_date}}"
            - name: notify-security
              type: call
              call: "slack.post-message"
              with:
                channel: "security-ops"
                text: "Secret rotation reminder: {{secret_name}} in {{repo_name}} expires {{expiration_date}}. Ticket: {{create-rotation-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Converts a street address to latitude and longitude coordinates using the Google Maps Geocoding API.

naftiko: "0.5"
info:
  label: "Google Maps Geocode Lookup"
  description: "Converts a street address to latitude and longitude coordinates using the Google Maps Geocoding API."
  tags:
    - maps
    - google-maps
    - geolocation
capability:
  exposes:
    - type: mcp
      namespace: geo-ops
      port: 8080
      tools:
        - name: geocode-address
          description: "Given a street address, return latitude and longitude coordinates. Use for driver service area validation and market analysis."
          inputParameters:
            - name: address
              in: body
              type: string
              description: "The street address to geocode."
          call: "google-maps.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"
  consumes:
    - type: http
      namespace: google-maps
      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

When a candidate advances in the hiring pipeline, updates the Salesforce recruiting record, creates a Jira interview scheduling ticket, and notifies the hiring team via Slack.

naftiko: "0.5"
info:
  label: "Greenhouse Candidate Stage Sync"
  description: "When a candidate advances in the hiring pipeline, updates the Salesforce recruiting record, creates a Jira interview scheduling ticket, and notifies the hiring team via Slack."
  tags:
    - recruiting
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: recruiting-sync
      port: 8080
      tools:
        - name: sync-candidate-stage
          description: "Given candidate details and new pipeline stage, update Salesforce, create scheduling ticket, and notify the team."
          inputParameters:
            - name: candidate_name
              in: body
              type: string
              description: "The candidate's name."
            - name: new_stage
              in: body
              type: string
              description: "New pipeline stage (e.g., phone_screen, onsite, offer)."
            - name: role_title
              in: body
              type: string
              description: "The role they applied for."
            - name: hiring_manager
              in: body
              type: string
              description: "The hiring manager's name."
          steps:
            - name: create-scheduling-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "RECRUIT"
                issuetype: "Task"
                summary: "Schedule {{new_stage}}: {{candidate_name}} for {{role_title}}"
            - name: notify-hiring-team
              type: call
              call: "slack.post-message"
              with:
                channel: "hiring-{{role_title}}"
                text: "{{candidate_name}} advanced to {{new_stage}} for {{role_title}}. HM: {{hiring_manager}}. Scheduling: {{create-scheduling-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new intern cohort starts, creates Jira project boards for each intern, provisions GitHub repo access, and sends welcome messages to the intern Slack channel.

naftiko: "0.5"
info:
  label: "Intern Project Kickoff"
  description: "When a new intern cohort starts, creates Jira project boards for each intern, provisions GitHub repo access, and sends welcome messages to the intern Slack channel."
  tags:
    - hr
    - onboarding
    - jira
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: intern-ops
      port: 8080
      tools:
        - name: kickoff-intern-project
          description: "Given intern details, create a Jira board, grant GitHub access, and welcome them on Slack."
          inputParameters:
            - name: intern_name
              in: body
              type: string
              description: "The intern's full name."
            - name: github_username
              in: body
              type: string
              description: "The intern's GitHub username."
            - name: team_name
              in: body
              type: string
              description: "The team the intern is assigned to."
            - name: project_name
              in: body
              type: string
              description: "The intern project name."
          steps:
            - name: create-project-board
              type: call
              call: "jira.create-issue"
              with:
                project_key: "INTERN"
                issuetype: "Epic"
                summary: "Intern project: {{project_name}} — {{intern_name}} ({{team_name}})"
            - name: grant-github-access
              type: call
              call: "github.add-team-member"
              with:
                team_slug: "{{team_name}}-interns"
                username: "{{github_username}}"
            - name: welcome-intern
              type: call
              call: "slack.post-message"
              with:
                channel: "interns-2026"
                text: "Welcome {{intern_name}} to the {{team_name}} team! Project: {{project_name}}. Jira: {{create-project-board.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: team-members
          path: "/orgs/uber/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_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Jira tickets are blocked for more than 48 hours, creates an escalation summary and posts it to the engineering management Slack channel.

naftiko: "0.5"
info:
  label: "Jira Blocked Tickets Escalation"
  description: "When Jira tickets are blocked for more than 48 hours, creates an escalation summary and posts it to the engineering management Slack channel."
  tags:
    - project-management
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: pm-ops
      port: 8080
      tools:
        - name: escalate-blocked-tickets
          description: "Given a project key, find blocked tickets older than 48h and escalate to management."
          inputParameters:
            - name: project_key
              in: body
              type: string
              description: "The Jira project key."
          steps:
            - name: find-blocked
              type: call
              call: "jira.search-issues"
              with:
                jql: "project={{project_key}} AND status=Blocked AND updated<='-48h'"
            - name: escalate
              type: call
              call: "slack.post-message"
              with:
                channel: "eng-management"
                text: "Blocked tickets escalation for {{project_key}}: {{find-blocked.total}} tickets blocked >48h. Review at https://uber.atlassian.net/issues/?jql=project%3D{{project_key}}%20AND%20status%3DBlocked"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current status, assignee, and priority for a Jira issue by key.

naftiko: "0.5"
info:
  label: "Jira Issue Status Lookup"
  description: "Retrieves the current status, assignee, and priority for a Jira issue by key."
  tags:
    - project-management
    - jira
capability:
  exposes:
    - type: mcp
      namespace: project-ops
      port: 8080
      tools:
        - name: get-issue-status
          description: "Given a Jira issue key, return its current status, assignee, and priority. Use for standup preparation and escalation decisions."
          inputParameters:
            - name: issue_key
              in: body
              type: string
              description: "The Jira issue key (e.g., ENG-1234)."
          call: "jira-issues.get-issue"
          with:
            issue_key: "{{issue_key}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.fields.status.name"
            - name: assignee
              type: string
              mapping: "$.fields.assignee.displayName"
            - name: priority
              type: string
              mapping: "$.fields.priority.name"
  consumes:
    - type: http
      namespace: jira-issues
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue/{{issue_key}}"
          inputParameters:
            - name: issue_key
              in: path
          operations:
            - name: get-issue
              method: GET

Pulls backlog and sprint data from Jira for a given engineering team, summarizes capacity and priority issues, and posts the sprint planning digest to the team's Slack channel.

naftiko: "0.5"
info:
  label: "Jira Sprint Planning Digest"
  description: "Pulls backlog and sprint data from Jira for a given engineering team, summarizes capacity and priority issues, and posts the sprint planning digest to the team's Slack channel."
  tags:
    - devops
    - agile
    - jira
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: sprint-planning
      port: 8080
      tools:
        - name: digest-sprint-planning
          description: "Given a Jira board ID, retrieve the backlog top priority items and upcoming sprint capacity, and post a sprint planning digest to the team's Slack channel."
          inputParameters:
            - name: board_id
              in: body
              type: string
              description: "The Jira board ID for the engineering team."
            - name: team_channel
              in: body
              type: string
              description: "Slack channel for the engineering team."
          steps:
            - name: get-backlog
              type: call
              call: "jira-sprint.get-backlog-issues"
              with:
                boardId: "{{board_id}}"
            - name: post-planning-digest
              type: call
              call: "slack-sprint.post-message"
              with:
                channel: "{{team_channel}}"
                text: "Sprint Planning: Board {{board_id}} | Backlog items: {{get-backlog.total}} | P1 items: {{get-backlog.p1_count}} | Ready to sprint: {{get-backlog.ready_count}}"
  consumes:
    - type: http
      namespace: jira-sprint
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: backlog-issues
          path: "/board/{{boardId}}/backlog"
          inputParameters:
            - name: boardId
              in: path
          operations:
            - name: get-backlog-issues
              method: GET
    - type: http
      namespace: slack-sprint
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects Kubernetes pod crash loops, creates a PagerDuty incident, opens a Jira ticket, and alerts the platform team in Slack.

naftiko: "0.5"
info:
  label: "Kubernetes Pod Failure Responder"
  description: "When Datadog detects Kubernetes pod crash loops, creates a PagerDuty incident, opens a Jira ticket, and alerts the platform team in Slack."
  tags:
    - infrastructure
    - datadog
    - pagerduty
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: k8s-ops
      port: 8080
      tools:
        - name: respond-to-pod-failures
          description: "Given a namespace, deployment, and failure count, escalate via PagerDuty, create a Jira ticket, and notify the team."
          inputParameters:
            - name: namespace
              in: body
              type: string
              description: "The Kubernetes namespace."
            - name: deployment
              in: body
              type: string
              description: "The deployment name."
            - name: restart_count
              in: body
              type: number
              description: "Number of pod restarts."
          steps:
            - name: create-pd-incident
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "K8s pod crash: {{deployment}} in {{namespace}} ({{restart_count}} restarts)"
                service_id: "PLATFORM_SRE"
            - name: create-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PLATFORM"
                issuetype: "Bug"
                summary: "K8s pod crash loop: {{deployment}} in {{namespace}}"
                description: "{{restart_count}} restarts detected."
            - name: alert-platform
              type: call
              call: "slack.post-message"
              with:
                channel: "platform-alerts"
                text: "K8s crash loop: {{deployment}} in {{namespace}} ({{restart_count}} restarts). PD: {{create-pd-incident.incident.id}}. Jira: {{create-ticket.key}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves LinkedIn Company Page follower growth and engagement metrics for Uber and posts a weekly employer brand digest to the talent marketing Slack channel.

naftiko: "0.5"
info:
  label: "LinkedIn Employer Brand Performance Digest"
  description: "Retrieves LinkedIn Company Page follower growth and engagement metrics for Uber and posts a weekly employer brand digest to the talent marketing Slack channel."
  tags:
    - marketing
    - employer-brand
    - linkedin
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: employer-brand
      port: 8080
      tools:
        - name: digest-linkedin-brand-metrics"
          description: "Given a reporting week, retrieve LinkedIn Company Page follower count, engagement rate, and top post performance for Uber, and post a digest to the talent marketing Slack channel."
          inputParameters:
            - name: linkedin_org_id
              in: body
              type: string
              description: "Uber's LinkedIn organization URN ID."
            - name: talent_channel
              in: body
              type: string
              description: "Slack channel for the talent marketing team."
          steps:
            - name: get-page-stats
              type: call
              call: "linkedin.get-organization-statistics"
              with:
                organizationId: "{{linkedin_org_id}}"
            - name: post-brand-digest
              type: call
              call: "slack-brand.post-message"
              with:
                channel: "{{talent_channel}}"
                text: "LinkedIn Brand Report: Uber | Followers: {{get-page-stats.follower_count}} | New followers (7d): {{get-page-stats.new_followers}} | Engagement rate: {{get-page-stats.engagement_rate}}% | Page views: {{get-page-stats.page_views}}"
  consumes:
    - type: http
      namespace: linkedin
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: organization-statistics
          path: "/organizationPageStatistics"
          inputParameters:
            - name: organizationId
              in: query
          operations:
            - name: get-organization-statistics
              method: GET
    - type: http
      namespace: slack-brand
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves view count and applicant metrics for an active LinkedIn job posting.

naftiko: "0.5"
info:
  label: "LinkedIn Job Posting Analytics"
  description: "Retrieves view count and applicant metrics for an active LinkedIn job posting."
  tags:
    - recruiting
    - linkedin
capability:
  exposes:
    - type: mcp
      namespace: recruiting-analytics
      port: 8080
      tools:
        - name: get-job-posting-metrics
          description: "Given a LinkedIn job posting ID, return view count and application count. Use for recruiting pipeline optimization."
          inputParameters:
            - name: job_posting_id
              in: body
              type: string
              description: "The LinkedIn job posting ID."
          call: "linkedin-jobs.get-job-analytics"
          with:
            job_id: "{{job_posting_id}}"
          outputParameters:
            - name: views
              type: number
              mapping: "$.views"
            - name: applications
              type: number
              mapping: "$.applications"
  consumes:
    - type: http
      namespace: linkedin-jobs
      baseUri: "https://api.linkedin.com/v2"
      authentication:
        type: bearer
        token: "$secrets.linkedin_token"
      resources:
        - name: job-analytics
          path: "/jobPostingAnalytics/{{job_id}}"
          inputParameters:
            - name: job_id
              in: path
          operations:
            - name: get-job-analytics
              method: GET

When a maps data quality issue is detected, creates a Jira ticket for the maps team, queries Snowflake for affected routes, and posts an alert to the maps engineering Slack channel.

naftiko: "0.5"
info:
  label: "Maps Data Quality Alert"
  description: "When a maps data quality issue is detected, creates a Jira ticket for the maps team, queries Snowflake for affected routes, and posts an alert to the maps engineering Slack channel."
  tags:
    - maps
    - jira
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: maps-quality
      port: 8080
      tools:
        - name: report-maps-quality-issue
          description: "Given a region and quality issue type, query affected routes, create a Jira ticket, and notify the maps team."
          inputParameters:
            - name: region
              in: body
              type: string
              description: "The geographic region affected."
            - name: issue_type
              in: body
              type: string
              description: "Type of quality issue (e.g., missing_road, incorrect_routing, stale_poi)."
          steps:
            - name: query-affected-routes
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT COUNT(*) AS affected_trips FROM maps.trip_routing WHERE region='{{region}}' AND quality_flag='{{issue_type}}' AND created_at>=DATEADD(day, -1, CURRENT_TIMESTAMP())"
            - name: create-quality-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "MAPS"
                issuetype: "Bug"
                summary: "Maps quality: {{issue_type}} in {{region}}"
                description: "Affected trips in last 24h: {{query-affected-routes.data}}"
            - name: alert-maps-team
              type: call
              call: "slack.post-message"
              with:
                channel: "maps-engineering"
                text: "Maps quality alert: {{issue_type}} in {{region}}. Jira: {{create-quality-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls service dependency data from Datadog service map, creates a Confluence dependency report, and posts a summary to the architecture Slack channel.

naftiko: "0.5"
info:
  label: "Microservice Dependency Audit"
  description: "Pulls service dependency data from Datadog service map, creates a Confluence dependency report, and posts a summary to the architecture Slack channel."
  tags:
    - architecture
    - datadog
    - confluence
    - slack
capability:
  exposes:
    - type: mcp
      namespace: arch-ops
      port: 8080
      tools:
        - name: audit-service-dependencies
          description: "Given a service name, pull its dependency graph from Datadog, document in Confluence, and notify architects."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The microservice name to audit."
          steps:
            - name: get-dependencies
              type: call
              call: "datadog.get-service-dependencies"
              with:
                service: "{{service_name}}"
            - name: create-dependency-doc
              type: call
              call: "confluence.create-page"
              with:
                spaceKey: "ARCH"
                title: "Dependency audit: {{service_name}}"
                body: "Service: {{service_name}}\nDependencies: {{get-dependencies.data}}"
            - name: notify-architects
              type: call
              call: "slack.post-message"
              with:
                channel: "architecture"
                text: "Dependency audit for {{service_name}} completed. Doc: {{create-dependency-doc._links.webui}}"
  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: service-map
          path: "/service_dependencies"
          operations:
            - name: get-service-dependencies
              method: GET
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an ML model's performance drops below threshold, queries Snowflake for model metrics, creates a Jira ticket for the ML team, and alerts the data science Slack channel.

naftiko: "0.5"
info:
  label: "ML Model Performance Degradation Alert"
  description: "When an ML model's performance drops below threshold, queries Snowflake for model metrics, creates a Jira ticket for the ML team, and alerts the data science Slack channel."
  tags:
    - machine-learning
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: ml-ops
      port: 8080
      tools:
        - name: alert-model-degradation
          description: "Given a model name and degraded metric, query performance data, create a Jira ticket, and notify the ML team."
          inputParameters:
            - name: model_name
              in: body
              type: string
              description: "The ML model name."
            - name: metric_name
              in: body
              type: string
              description: "The degraded metric (e.g., accuracy, precision, AUC)."
            - name: current_value
              in: body
              type: number
              description: "Current metric value."
            - name: threshold
              in: body
              type: number
              description: "Expected minimum threshold."
          steps:
            - name: query-model-history
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT model_version, {{metric_name}}, evaluated_at FROM ml.model_metrics WHERE model_name='{{model_name}}' ORDER BY evaluated_at DESC LIMIT 10"
            - name: create-ml-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ML"
                issuetype: "Bug"
                summary: "Model degradation: {{model_name}} — {{metric_name}} at {{current_value}} (threshold: {{threshold}})"
                description: "Recent metrics: {{query-model-history.data}}"
            - name: alert-ml-team
              type: call
              call: "slack.post-message"
              with:
                channel: "ml-platform-alerts"
                text: "Model {{model_name}} degraded: {{metric_name}}={{current_value}} (threshold: {{threshold}}). Jira: {{create-ml-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When mobile app crash rates spike, queries Datadog for crash metrics, creates a Jira P1 ticket for the mobile team, and alerts the mobile engineering Slack channel.

naftiko: "0.5"
info:
  label: "Mobile App Crash Rate Monitor"
  description: "When mobile app crash rates spike, queries Datadog for crash metrics, creates a Jira P1 ticket for the mobile team, and alerts the mobile engineering Slack channel."
  tags:
    - mobile
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: mobile-ops
      port: 8080
      tools:
        - name: handle-crash-rate-spike
          description: "Given a platform and crash rate, create a P1 ticket and alert the mobile team."
          inputParameters:
            - name: platform
              in: body
              type: string
              description: "Mobile platform (ios or android)."
            - name: crash_rate
              in: body
              type: number
              description: "Current crash rate percentage."
            - name: app_version
              in: body
              type: string
              description: "The app version experiencing crashes."
          steps:
            - name: create-crash-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "MOBILE"
                issuetype: "Bug"
                summary: "[P1] Crash rate spike: {{platform}} v{{app_version}} at {{crash_rate}}%"
                priority: "Highest"
            - name: alert-mobile-team
              type: call
              call: "slack.post-message"
              with:
                channel: "mobile-{{platform}}-engineering"
                text: "CRASH RATE SPIKE: {{platform}} v{{app_version}} at {{crash_rate}}%. Jira: {{create-crash-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When entering a new regulatory market, creates a Jira epic for regulatory compliance tasks, documents requirements in Confluence, and notifies the legal team via Slack.

naftiko: "0.5"
info:
  label: "New City Regulatory Checklist"
  description: "When entering a new regulatory market, creates a Jira epic for regulatory compliance tasks, documents requirements in Confluence, and notifies the legal team via Slack."
  tags:
    - legal
    - regulatory
    - jira
    - confluence
    - slack
capability:
  exposes:
    - type: mcp
      namespace: regulatory-ops
      port: 8080
      tools:
        - name: create-regulatory-checklist
          description: "Given a city and regulatory framework, create compliance tracking in Jira, document in Confluence, and notify legal."
          inputParameters:
            - name: city
              in: body
              type: string
              description: "The city or jurisdiction."
            - name: regulatory_framework
              in: body
              type: string
              description: "The regulatory framework (e.g., TNC, taxi, rideshare)."
          steps:
            - name: create-compliance-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "LEGAL"
                issuetype: "Epic"
                summary: "Regulatory compliance: {{city}} — {{regulatory_framework}}"
            - name: create-requirements-doc
              type: call
              call: "confluence.create-page"
              with:
                spaceKey: "LEGAL"
                title: "Regulatory requirements: {{city}} ({{regulatory_framework}})"
                body: "City: {{city}}\nFramework: {{regulatory_framework}}\nEpic: {{create-compliance-epic.key}}\nStatus: In Progress"
            - name: notify-legal
              type: call
              call: "slack.post-message"
              with:
                channel: "legal-regulatory"
                text: "New regulatory checklist for {{city}} ({{regulatory_framework}}). Epic: {{create-compliance-epic.key}}. Docs: {{create-requirements-doc._links.webui}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a new city market launch is initiated, creates a Jira epic with subtasks for regulatory, operations, and marketing workstreams, provisions a Slack channel, and posts a kickoff announcement.

naftiko: "0.5"
info:
  label: "New Market Launch Checklist"
  description: "When a new city market launch is initiated, creates a Jira epic with subtasks for regulatory, operations, and marketing workstreams, provisions a Slack channel, and posts a kickoff announcement."
  tags:
    - operations
    - jira
    - slack
    - market-expansion
capability:
  exposes:
    - type: mcp
      namespace: market-ops
      port: 8080
      tools:
        - name: initiate-market-launch
          description: "Given a city name and launch date, create a Jira launch epic, provision a dedicated Slack channel, and announce the kickoff."
          inputParameters:
            - name: city_name
              in: body
              type: string
              description: "The name of the city for market launch."
            - name: launch_date
              in: body
              type: string
              description: "Target launch date in YYYY-MM-DD format."
            - name: market_lead
              in: body
              type: string
              description: "The email of the market launch lead."
          steps:
            - name: create-launch-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "LAUNCH"
                issuetype: "Epic"
                summary: "Market Launch: {{city_name}} — Target {{launch_date}}"
            - name: create-slack-channel
              type: call
              call: "slack.create-channel"
              with:
                name: "launch-{{city_name}}"
                is_private: false
            - name: post-kickoff
              type: call
              call: "slack.post-message"
              with:
                channel: "{{create-slack-channel.channel.id}}"
                text: "Market launch for {{city_name}} initiated! Epic: {{create-launch-epic.key}}. Lead: {{market_lead}}. Target: {{launch_date}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: channels
          path: "/conversations.create"
          operations:
            - name: create-channel
              method: POST
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Queries Workday headcount data, compares against office capacity in Snowflake, and posts a capacity forecast to the workplace ops Slack channel.

naftiko: "0.5"
info:
  label: "Office Space Capacity Planner"
  description: "Queries Workday headcount data, compares against office capacity in Snowflake, and posts a capacity forecast to the workplace ops Slack channel."
  tags:
    - workplace
    - workday
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: workplace-ops
      port: 8080
      tools:
        - name: forecast-office-capacity
          description: "Given an office location, pull headcount and capacity data, and post a forecast."
          inputParameters:
            - name: office_location
              in: body
              type: string
              description: "The office location (e.g., SF-HQ, NYC, Amsterdam)."
          steps:
            - name: query-capacity
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT total_desks, occupied_desks, utilization_pct FROM workplace.office_capacity WHERE location='{{office_location}}'"
            - name: post-forecast
              type: call
              call: "slack.post-message"
              with:
                channel: "workplace-ops"
                text: "Office capacity for {{office_location}}: {{query-capacity.data}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Workday team change occurs, updates the employee's Okta group memberships, provisions new GitHub team access, and logs the change in Jira.

naftiko: "0.5"
info:
  label: "Okta Group Membership Sync"
  description: "When a Workday team change occurs, updates the employee's Okta group memberships, provisions new GitHub team access, and logs the change in Jira."
  tags:
    - identity
    - okta
    - workday
    - github
    - jira
capability:
  exposes:
    - type: mcp
      namespace: identity-sync
      port: 8080
      tools:
        - name: sync-group-membership
          description: "Given an employee ID, old team, and new team, update Okta groups, GitHub teams, and log the change."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID."
            - name: old_team
              in: body
              type: string
              description: "Previous team name."
            - name: new_team
              in: body
              type: string
              description: "New team name."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: update-okta-group
              type: call
              call: "okta.add-user-to-group"
              with:
                user_id: "{{get-employee.okta_id}}"
                group_id: "{{new_team}}_okta_group"
            - name: update-github-team
              type: call
              call: "github.add-team-member"
              with:
                team_slug: "{{new_team}}"
                username: "{{get-employee.github_username}}"
            - name: log-change
              type: call
              call: "jira.create-issue"
              with:
                project_key: "IT"
                issuetype: "Task"
                summary: "Team transfer: {{get-employee.full_name}} from {{old_team}} to {{new_team}}"
  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: okta
      baseUri: "https://uber.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: group-members
          path: "/groups/{{group_id}}/users/{{user_id}}"
          inputParameters:
            - name: group_id
              in: path
            - name: user_id
              in: path
          operations:
            - name: add-user-to-group
              method: PUT
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: team-members
          path: "/orgs/uber/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://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST

When an Okta suspicious login event is detected, suspends the user account, creates a CrowdStrike investigation, and alerts the security team via Slack.

naftiko: "0.5"
info:
  label: "Okta Suspicious Login Response"
  description: "When an Okta suspicious login event is detected, suspends the user account, creates a CrowdStrike investigation, and alerts the security team via Slack."
  tags:
    - security
    - okta
    - crowdstrike
    - slack
capability:
  exposes:
    - type: mcp
      namespace: security-response
      port: 8080
      tools:
        - name: respond-to-suspicious-login
          description: "Given an Okta user ID and suspicious event details, suspend the account, open a CrowdStrike investigation, and notify security."
          inputParameters:
            - name: user_id
              in: body
              type: string
              description: "The Okta user ID."
            - name: event_type
              in: body
              type: string
              description: "Type of suspicious event (e.g., impossible_travel, brute_force)."
            - name: source_ip
              in: body
              type: string
              description: "The source IP address of the suspicious login."
          steps:
            - name: suspend-user
              type: call
              call: "okta.suspend-user"
              with:
                user_id: "{{user_id}}"
            - name: create-investigation
              type: call
              call: "crowdstrike.create-detection"
              with:
                description: "Okta suspicious login: {{event_type}} from {{source_ip}} for user {{user_id}}"
            - name: alert-security
              type: call
              call: "slack.post-message"
              with:
                channel: "security-incidents"
                text: "ALERT: Okta user {{user_id}} suspended. Event: {{event_type}} from IP {{source_ip}}. CS investigation: {{create-investigation.detection_id}}"
  consumes:
    - type: http
      namespace: okta
      baseUri: "https://uber.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users/{{user_id}}/lifecycle/suspend"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: suspend-user
              method: POST
    - type: http
      namespace: crowdstrike
      baseUri: "https://api.crowdstrike.com"
      authentication:
        type: bearer
        token: "$secrets.crowdstrike_token"
      resources:
        - name: detections
          path: "/detects/entities/detects/v2"
          operations:
            - name: create-detection
              method: PATCH
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an Uber employee separates, deactivates their Okta account, removes GitHub org membership, and notifies HR via Slack with a confirmation of access removal.

naftiko: "0.5"
info:
  label: "Okta User Deprovisioning on Offboarding"
  description: "When an Uber employee separates, deactivates their Okta account, removes GitHub org membership, and notifies HR via Slack with a confirmation of access removal."
  tags:
    - hr
    - offboarding
    - okta
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-offboarding
      port: 8080
      tools:
        - name: deprovision-departing-employee
          description: "Given an Okta user ID and GitHub username, deactivate Okta access, remove from GitHub org, and notify HR in Slack confirming all access has been revoked."
          inputParameters:
            - name: okta_user_id
              in: body
              type: string
              description: "The departing employee's Okta user ID."
            - name: github_username
              in: body
              type: string
              description: "The departing employee's GitHub username."
            - name: employee_name
              in: body
              type: string
              description: "Full name of the departing employee."
            - name: hr_channel
              in: body
              type: string
              description: "Slack channel for HR to receive the offboarding confirmation."
          steps:
            - name: deactivate-okta
              type: call
              call: "okta-off.deactivate-user"
              with:
                user_id: "{{okta_user_id}}"
            - name: remove-github
              type: call
              call: "github-off.remove-member"
              with:
                username: "{{github_username}}"
            - name: confirm-hr
              type: call
              call: "slack-off.post-message"
              with:
                channel: "{{hr_channel}}"
                text: "Offboarding complete: {{employee_name}} | Okta deactivated: {{deactivate-okta.status}} | GitHub removed: {{remove-github.status}}"
  consumes:
    - type: http
      namespace: okta-off
      baseUri: "https://uber.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users/{{user_id}}/lifecycle/deactivate"
          inputParameters:
            - name: user_id
              in: path
          operations:
            - name: deactivate-user
              method: POST
    - type: http
      namespace: github-off
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: org-members
          path: "/orgs/uber/members/{{username}}"
          inputParameters:
            - name: username
              in: path
          operations:
            - name: remove-member
              method: DELETE
    - type: http
      namespace: slack-off
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current status and profile for an Okta user by email address.

naftiko: "0.5"
info:
  label: "Okta User Status Lookup"
  description: "Retrieves the current status and profile for an Okta user by email address."
  tags:
    - identity
    - okta
    - security
capability:
  exposes:
    - type: mcp
      namespace: identity-ops
      port: 8080
      tools:
        - name: get-okta-user-status
          description: "Given an employee email, return their Okta account status, last login, and group memberships. Use for access reviews and incident response."
          inputParameters:
            - name: email
              in: body
              type: string
              description: "The employee email address."
          call: "okta-users.get-user"
          with:
            login: "{{email}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.status"
            - name: last_login
              type: string
              mapping: "$.lastLogin"
  consumes:
    - type: http
      namespace: okta-users
      baseUri: "https://uber.okta.com/api/v1"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.okta_api_token"
        placement: header
      resources:
        - name: users
          path: "/users/{{login}}"
          inputParameters:
            - name: login
              in: path
          operations:
            - name: get-user
              method: GET

Scans a GitHub repository's dependency tree for license compliance issues, creates a Jira ticket for any violations, and alerts the legal-engineering Slack channel.

naftiko: "0.5"
info:
  label: "Open Source License Compliance Check"
  description: "Scans a GitHub repository's dependency tree for license compliance issues, creates a Jira ticket for any violations, and alerts the legal-engineering Slack channel."
  tags:
    - legal
    - github
    - jira
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: oss-compliance
      port: 8080
      tools:
        - name: check-license-compliance
          description: "Given a GitHub repo, scan dependencies for license issues, create a ticket if violations found, and notify legal."
          inputParameters:
            - name: repo_name
              in: body
              type: string
              description: "The GitHub repository name."
          steps:
            - name: get-dependency-graph
              type: call
              call: "github.get-dependency-graph"
              with:
                repo: "{{repo_name}}"
            - name: create-compliance-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "LEGAL"
                issuetype: "Task"
                summary: "OSS license audit: {{repo_name}}"
                description: "Dependency graph: {{get-dependency-graph.sbom}}"
            - name: notify-legal-eng
              type: call
              call: "slack.post-message"
              with:
                channel: "legal-engineering"
                text: "OSS license audit initiated for {{repo_name}}. Jira: {{create-compliance-ticket.key}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: dependency-graph
          path: "/repos/uber/{{repo}}/dependency-graph/sbom"
          inputParameters:
            - name: repo
              in: path
          operations:
            - name: get-dependency-graph
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current on-call engineer for a given PagerDuty schedule.

naftiko: "0.5"
info:
  label: "PagerDuty On-Call Schedule Lookup"
  description: "Retrieves the current on-call engineer for a given PagerDuty schedule."
  tags:
    - incident-response
    - pagerduty
capability:
  exposes:
    - type: mcp
      namespace: oncall-ops
      port: 8080
      tools:
        - name: get-oncall-engineer
          description: "Given a PagerDuty schedule ID, return the currently on-call engineer's name and contact info. Use during incident escalation."
          inputParameters:
            - name: schedule_id
              in: body
              type: string
              description: "The PagerDuty schedule ID."
          call: "pagerduty-schedules.get-oncall"
          with:
            schedule_id: "{{schedule_id}}"
          outputParameters:
            - name: oncall_name
              type: string
              mapping: "$.schedule.final_schedule.rendered_schedule_entries[0].user.summary"
            - name: oncall_email
              type: string
              mapping: "$.schedule.final_schedule.rendered_schedule_entries[0].user.email"
  consumes:
    - type: http
      namespace: pagerduty-schedules
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: schedules
          path: "/schedules/{{schedule_id}}"
          inputParameters:
            - name: schedule_id
              in: path
          operations:
            - name: get-oncall
              method: GET

When a new partner integration is approved, provisions an API key, creates a Jira onboarding ticket, and sends credentials to the partner via SendGrid.

naftiko: "0.5"
info:
  label: "Partner API Key Provisioning"
  description: "When a new partner integration is approved, provisions an API key, creates a Jira onboarding ticket, and sends credentials to the partner via SendGrid."
  tags:
    - partnerships
    - jira
    - sendgrid
    - api-management
capability:
  exposes:
    - type: mcp
      namespace: partner-ops
      port: 8080
      tools:
        - name: provision-partner-api-key
          description: "Given partner details and integration scope, create an onboarding ticket and send credentials."
          inputParameters:
            - name: partner_name
              in: body
              type: string
              description: "Partner company name."
            - name: contact_email
              in: body
              type: string
              description: "Partner technical contact email."
            - name: integration_scope
              in: body
              type: string
              description: "API scope (e.g., rides, eats, freight)."
          steps:
            - name: create-onboarding-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PARTNER"
                issuetype: "Task"
                summary: "API onboarding: {{partner_name}} — {{integration_scope}}"
            - name: send-credentials
              type: call
              call: "sendgrid.send-email"
              with:
                to: "{{contact_email}}"
                subject: "Your Uber API integration is ready"
                body: "Welcome {{partner_name}}! Your integration for {{integration_scope}} has been provisioned. Onboarding ticket: {{create-onboarding-ticket.key}}."
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: sendgrid
      baseUri: "https://api.sendgrid.com/v3"
      authentication:
        type: bearer
        token: "$secrets.sendgrid_api_key"
      resources:
        - name: mail
          path: "/mail/send"
          operations:
            - name: send-email
              method: POST

When a payment processing failure rate exceeds threshold, creates a PagerDuty incident, opens a Jira P1 ticket, and alerts the payments team via Slack.

naftiko: "0.5"
info:
  label: "Payment Processing Failure Handler"
  description: "When a payment processing failure rate exceeds threshold, creates a PagerDuty incident, opens a Jira P1 ticket, and alerts the payments team via Slack."
  tags:
    - payments
    - pagerduty
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: payments-ops
      port: 8080
      tools:
        - name: handle-payment-failure
          description: "Given payment provider and failure rate, page on-call, create a P1 ticket, and alert the payments team."
          inputParameters:
            - name: payment_provider
              in: body
              type: string
              description: "The payment provider experiencing failures."
            - name: failure_rate
              in: body
              type: number
              description: "Current failure rate percentage."
            - name: affected_market
              in: body
              type: string
              description: "The market affected."
          steps:
            - name: page-payments-oncall
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "Payment failure: {{payment_provider}} at {{failure_rate}}% in {{affected_market}}"
                service_id: "PAYMENTS_SRE"
            - name: create-p1-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PAY"
                issuetype: "Bug"
                summary: "[P1] Payment failures: {{payment_provider}} — {{failure_rate}}% — {{affected_market}}"
                priority: "Highest"
            - name: alert-payments
              type: call
              call: "slack.post-message"
              with:
                channel: "payments-alerts"
                text: "PAYMENT FAILURE: {{payment_provider}} at {{failure_rate}}% in {{affected_market}}. PD: {{page-payments-oncall.incident.id}}. Jira: {{create-p1-ticket.key}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a P1 incident is resolved, creates a Confluence postmortem page from a template, assigns action items in Jira, and schedules a review meeting reminder in Slack.

naftiko: "0.5"
info:
  label: "Postmortem Creation Workflow"
  description: "When a P1 incident is resolved, creates a Confluence postmortem page from a template, assigns action items in Jira, and schedules a review meeting reminder in Slack."
  tags:
    - sre
    - confluence
    - jira
    - slack
    - incident-response
capability:
  exposes:
    - type: mcp
      namespace: postmortem-ops
      port: 8080
      tools:
        - name: create-postmortem
          description: "Given an incident ticket key and details, create a Confluence postmortem, Jira action items, and schedule a Slack review."
          inputParameters:
            - name: incident_key
              in: body
              type: string
              description: "The Jira incident ticket key."
            - name: incident_summary
              in: body
              type: string
              description: "Brief summary of the incident."
            - name: owning_team
              in: body
              type: string
              description: "The team that owned the incident response."
          steps:
            - name: create-postmortem-page
              type: call
              call: "confluence.create-page"
              with:
                spaceKey: "SRE"
                title: "Postmortem: {{incident_key}} — {{incident_summary}}"
                body: "# Postmortem: {{incident_key}}\n## Summary\n{{incident_summary}}\n## Timeline\nTBD\n## Root Cause\nTBD\n## Action Items\nTBD"
            - name: create-action-item
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SRE"
                issuetype: "Task"
                summary: "Postmortem action items: {{incident_key}}"
                description: "Complete postmortem action items from {{create-postmortem-page.id}}"
            - name: schedule-review
              type: call
              call: "slack.post-message"
              with:
                channel: "{{owning_team}}-engineering"
                text: "Postmortem created for {{incident_key}}: {{incident_summary}}. Page: {{create-postmortem-page._links.webui}}. Action items: {{create-action-item.key}}. Please schedule a review within 5 business days."
  consumes:
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content"
          operations:
            - name: create-page
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Datadog detects a P1 service degradation for a core Uber product, triggers PagerDuty, opens a Jira incident issue, and posts an incident bridge to the Slack ops channel.

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

Pulls key metrics from Snowflake, revenue data from Salesforce, and engineering velocity from Jira, then compiles and posts a QBR summary to the leadership Slack channel.

naftiko: "0.5"
info:
  label: "Quarterly Business Review Digest"
  description: "Pulls key metrics from Snowflake, revenue data from Salesforce, and engineering velocity from Jira, then compiles and posts a QBR summary to the leadership Slack channel."
  tags:
    - business-intelligence
    - snowflake
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: qbr-digest
      port: 8080
      tools:
        - name: generate-qbr-digest
          description: "Given a fiscal quarter, pull metrics from Snowflake, Salesforce revenue data, and Jira delivery stats, then post a compiled summary to Slack."
          inputParameters:
            - name: fiscal_quarter
              in: body
              type: string
              description: "The fiscal quarter (e.g., Q1-2026)."
            - name: business_unit
              in: body
              type: string
              description: "Business unit (e.g., Rides, Eats, Freight)."
          steps:
            - name: query-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT * FROM analytics.qbr_metrics WHERE quarter='{{fiscal_quarter}}' AND bu='{{business_unit}}'"
            - name: get-revenue-pipeline
              type: call
              call: "salesforce.query-records"
              with:
                q: "SELECT SUM(Amount) FROM Opportunity WHERE FiscalQuarter='{{fiscal_quarter}}' AND Business_Unit__c='{{business_unit}}' AND StageName='Closed Won'"
            - name: get-delivery-velocity
              type: call
              call: "jira.search-issues"
              with:
                jql: "project={{business_unit}} AND status=Done AND resolved>=-90d"
            - name: post-qbr-summary
              type: call
              call: "slack.post-message"
              with:
                channel: "leadership-{{business_unit}}"
                text: "QBR Digest for {{business_unit}} — {{fiscal_quarter}}\nMetrics: {{query-metrics.data}}\nRevenue: {{get-revenue-pipeline.records[0].expr0}}\nTickets Delivered: {{get-delivery-velocity.total}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: salesforce
      baseUri: "https://uber.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: query
          path: "/query"
          operations:
            - name: query-records
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Initiates a quarterly access review by querying Okta for all active users, creating Jira review tickets for each team manager, and posting the review kickoff to the security Slack channel.

naftiko: "0.5"
info:
  label: "Quarterly Security Access Review"
  description: "Initiates a quarterly access review by querying Okta for all active users, creating Jira review tickets for each team manager, and posting the review kickoff to the security Slack channel."
  tags:
    - security
    - okta
    - jira
    - slack
    - compliance
capability:
  exposes:
    - type: mcp
      namespace: access-review
      port: 8080
      tools:
        - name: launch-access-review
          description: "Given a review quarter and deadline, create review tracking tickets and notify the security team."
          inputParameters:
            - name: review_quarter
              in: body
              type: string
              description: "The quarter (e.g., Q1-2026)."
            - name: deadline
              in: body
              type: string
              description: "Review completion deadline."
          steps:
            - name: create-review-epic
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Epic"
                summary: "Quarterly access review: {{review_quarter}} — due {{deadline}}"
            - name: announce-review
              type: call
              call: "slack.post-message"
              with:
                channel: "security-ops"
                text: "Quarterly access review {{review_quarter}} launched! Deadline: {{deadline}}. Epic: {{create-review-epic.key}}. All managers: please review your team's access in Okta."
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls open requisitions and candidate pipeline metrics from Workday Recruiting for all engineering teams and posts a weekly hiring health digest to the HR leadership Slack channel.

naftiko: "0.5"
info:
  label: "Recruiting Pipeline Health Digest"
  description: "Pulls open requisitions and candidate pipeline metrics from Workday Recruiting for all engineering teams and posts a weekly hiring health digest to the HR leadership Slack channel."
  tags:
    - hr
    - recruiting
    - workday
    - slack
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: recruiting-ops
      port: 8080
      tools:
        - name: digest-recruiting-health
          description: "Given a business unit, retrieve open job requisitions and candidate pipeline stages from Workday, and post a weekly recruiting health digest to the HR leadership Slack channel."
          inputParameters:
            - name: business_unit
              in: body
              type: string
              description: "Business unit to report on (e.g., Rides, Eats, Freight, Platform)."
            - name: hr_channel
              in: body
              type: string
              description: "Slack channel for HR leadership digest."
          steps:
            - name: get-open-reqs
              type: call
              call: "workday-recruiting.get-requisitions"
              with:
                businessUnit: "{{business_unit}}"
                status: "open"
            - name: post-recruiting-digest
              type: call
              call: "slack-recruiting.post-message"
              with:
                channel: "{{hr_channel}}"
                text: "Recruiting Health — {{business_unit}}: Open reqs: {{get-open-reqs.open_count}} | Candidates: {{get-open-reqs.candidate_count}} | Avg time-to-fill: {{get-open-reqs.avg_days_open}} days | Offers pending: {{get-open-reqs.offers_pending}}"
  consumes:
    - type: http
      namespace: workday-recruiting
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: requisitions
          path: "/jobRequisitions"
          inputParameters:
            - name: businessUnit
              in: query
            - name: status
              in: query
          operations:
            - name: get-requisitions
              method: GET
    - type: http
      namespace: slack-recruiting
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a regulatory audit is initiated, creates a ServiceNow compliance project, assigns evidence collection tasks to the legal and engineering teams, and notifies all stakeholders via Slack.

naftiko: "0.5"
info:
  label: "Regulatory Compliance Audit Tracking"
  description: "When a regulatory audit is initiated, creates a ServiceNow compliance project, assigns evidence collection tasks to the legal and engineering teams, and notifies all stakeholders via Slack."
  tags:
    - compliance
    - legal
    - servicenow
    - slack
capability:
  exposes:
    - type: mcp
      namespace: compliance-ops
      port: 8080
      tools:
        - name: initiate-compliance-audit"
          description: "Given an audit type, regulatory body, and due date, create a ServiceNow compliance project with evidence collection tasks and notify all stakeholders via Slack."
          inputParameters:
            - name: audit_type
              in: body
              type: string
              description: "Type of regulatory audit (e.g., SOC 2 Type II, GDPR, PCI DSS)."
            - name: regulatory_body
              in: body
              type: string
              description: "Name of the regulatory body conducting the audit."
            - name: due_date
              in: body
              type: string
              description: "Audit evidence submission deadline in YYYY-MM-DD format."
            - name: compliance_channel
              in: body
              type: string
              description: "Slack channel for the compliance and legal team."
          steps:
            - name: create-audit-project
              type: call
              call: "servicenow-compliance.create-task"
              with:
                short_description: "{{audit_type}} audit — {{regulatory_body}} — due {{due_date}}"
                category: "compliance_audit"
                assignment_group: "Legal_Compliance"
                due_date: "{{due_date}}"
            - name: notify-stakeholders
              type: call
              call: "slack-compliance.post-message"
              with:
                channel: "{{compliance_channel}}"
                text: "Compliance audit initiated: {{audit_type}} | Regulator: {{regulatory_body}} | Evidence due: {{due_date}} | Task: {{create-audit-project.number}}"
  consumes:
    - type: http
      namespace: servicenow-compliance
      baseUri: "https://uber.service-now.com/api/now"
      authentication:
        type: basic
        username: "$secrets.servicenow_user"
        password: "$secrets.servicenow_password"
      resources:
        - name: tasks
          path: "/table/sc_task"
          operations:
            - name: create-task
              method: POST
    - type: http
      namespace: slack-compliance
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When actual revenue deviates from forecast by more than a threshold, queries Snowflake for revenue data, creates a Jira analysis ticket, and alerts the finance team via Slack.

naftiko: "0.5"
info:
  label: "Revenue Forecast Variance Alert"
  description: "When actual revenue deviates from forecast by more than a threshold, queries Snowflake for revenue data, creates a Jira analysis ticket, and alerts the finance team via Slack."
  tags:
    - finance
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: finance-ops
      port: 8080
      tools:
        - name: alert-revenue-variance
          description: "Given a business unit and variance percentage, pull revenue data, create an analysis ticket, and notify finance."
          inputParameters:
            - name: business_unit
              in: body
              type: string
              description: "The business unit."
            - name: variance_pct
              in: body
              type: number
              description: "Variance from forecast percentage."
            - name: period
              in: body
              type: string
              description: "The fiscal period (e.g., March 2026)."
          steps:
            - name: query-revenue
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT actual_revenue, forecast_revenue, (actual_revenue-forecast_revenue)/forecast_revenue*100 as variance_pct FROM finance.revenue_actuals WHERE bu='{{business_unit}}' AND period='{{period}}'"
            - name: create-analysis-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "FIN"
                issuetype: "Task"
                summary: "Revenue variance: {{business_unit}} at {{variance_pct}}% for {{period}}"
            - name: alert-finance
              type: call
              call: "slack.post-message"
              with:
                channel: "finance-alerts"
                text: "Revenue variance alert: {{business_unit}} for {{period}} is {{variance_pct}}% from forecast. Data: {{query-revenue.data}}. Ticket: {{create-analysis-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a high-priority rider complaint is logged, retrieves trip details from the internal trips API, creates a Jira ticket for the support team, and sends an escalation alert to the Slack support channel.

naftiko: "0.5"
info:
  label: "Rider Support Escalation Workflow"
  description: "When a high-priority rider complaint is logged, retrieves trip details from the internal trips API, creates a Jira ticket for the support team, and sends an escalation alert to the Slack support channel."
  tags:
    - customer-service
    - jira
    - slack
    - support
capability:
  exposes:
    - type: mcp
      namespace: rider-support
      port: 8080
      tools:
        - name: escalate-rider-complaint
          description: "Given a trip ID and complaint category, pull trip details, create a Jira support ticket, and alert the support Slack channel."
          inputParameters:
            - name: trip_id
              in: body
              type: string
              description: "The Uber trip ID."
            - name: complaint_category
              in: body
              type: string
              description: "Category of complaint (e.g., safety, billing, driver_conduct)."
            - name: rider_email
              in: body
              type: string
              description: "The rider's email address."
          steps:
            - name: create-support-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SUPPORT"
                issuetype: "Bug"
                summary: "Rider escalation: {{complaint_category}} — Trip {{trip_id}}"
                description: "Rider {{rider_email}} reported {{complaint_category}} for trip {{trip_id}}."
                priority: "High"
            - name: notify-support-channel
              type: call
              call: "slack.post-message"
              with:
                channel: "rider-support-escalations"
                text: "Escalation {{create-support-ticket.key}}: {{complaint_category}} for trip {{trip_id}} from {{rider_email}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the access policy and public access configuration for an AWS S3 bucket.

naftiko: "0.5"
info:
  label: "S3 Bucket Access Audit"
  description: "Retrieves the access policy and public access configuration for an AWS S3 bucket."
  tags:
    - security
    - aws
    - s3
capability:
  exposes:
    - type: mcp
      namespace: cloud-security
      port: 8080
      tools:
        - name: audit-s3-access
          description: "Given an S3 bucket name, return its access policy and public access block status. Use for security compliance checks."
          inputParameters:
            - name: bucket_name
              in: body
              type: string
              description: "The S3 bucket name."
          call: "aws-s3.get-bucket-policy-status"
          with:
            bucket: "{{bucket_name}}"
          outputParameters:
            - name: is_public
              type: boolean
              mapping: "$.PolicyStatus.IsPublic"
  consumes:
    - type: http
      namespace: aws-s3
      baseUri: "https://{{bucket}}.s3.amazonaws.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.aws_auth_header"
        placement: header
      resources:
        - name: policy-status
          path: "/?policyStatus"
          inputParameters:
            - name: bucket
              in: path
          operations:
            - name: get-bucket-policy-status
              method: GET

When a safety incident is reported, creates a Jira tracking ticket, logs incident details in Snowflake for regulatory reporting, and notifies the legal and safety teams via Slack.

naftiko: "0.5"
info:
  label: "Safety Incident Regulatory Report"
  description: "When a safety incident is reported, creates a Jira tracking ticket, logs incident details in Snowflake for regulatory reporting, and notifies the legal and safety teams via Slack."
  tags:
    - safety
    - compliance
    - jira
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: safety-compliance
      port: 8080
      tools:
        - name: report-safety-incident
          description: "Given incident details, create a tracking ticket, log for regulatory reporting, and notify legal and safety teams."
          inputParameters:
            - name: incident_type
              in: body
              type: string
              description: "Type of safety incident."
            - name: market
              in: body
              type: string
              description: "City/market where the incident occurred."
            - name: trip_id
              in: body
              type: string
              description: "Associated trip ID."
            - name: severity
              in: body
              type: string
              description: "Severity level: critical, high, medium."
          steps:
            - name: create-safety-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SAFETY"
                issuetype: "Bug"
                summary: "[{{severity}}] Safety incident: {{incident_type}} in {{market}}"
                priority: "{{severity}}"
            - name: log-for-regulatory
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO compliance.safety_incidents (incident_type, market, trip_id, severity, ticket_key, reported_at) VALUES ('{{incident_type}}', '{{market}}', '{{trip_id}}', '{{severity}}', '{{create-safety-ticket.key}}', CURRENT_TIMESTAMP())"
            - name: notify-safety-legal
              type: call
              call: "slack.post-message"
              with:
                channel: "safety-legal-alerts"
                text: "Safety incident [{{severity}}]: {{incident_type}} in {{market}}. Trip: {{trip_id}}. Jira: {{create-safety-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves account health score, contract renewal date, and ARR for a Salesforce enterprise account.

naftiko: "0.5"
info:
  label: "Salesforce Account Health Lookup"
  description: "Retrieves account health score, contract renewal date, and ARR for a Salesforce enterprise account."
  tags:
    - sales
    - salesforce
    - account-management
capability:
  exposes:
    - type: mcp
      namespace: sales-ops
      port: 8080
      tools:
        - name: get-account-health
          description: "Given a Salesforce account ID, return health score, next renewal date, and current ARR. Use for customer success reviews and churn risk assessment."
          inputParameters:
            - name: account_id
              in: body
              type: string
              description: "The Salesforce account ID."
          call: "salesforce-accounts.get-account"
          with:
            account_id: "{{account_id}}"
          outputParameters:
            - name: health_score
              type: number
              mapping: "$.Health_Score__c"
            - name: renewal_date
              type: string
              mapping: "$.Contract_Renewal_Date__c"
            - name: arr
              type: number
              mapping: "$.ARR__c"
  consumes:
    - type: http
      namespace: salesforce-accounts
      baseUri: "https://uber.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

When a Salesforce deal moves to Closed Won, creates a Jira implementation project, notifies the customer success team in Slack, and logs the win in Snowflake.

naftiko: "0.5"
info:
  label: "Salesforce Deal Closed Won Orchestrator"
  description: "When a Salesforce deal moves to Closed Won, creates a Jira implementation project, notifies the customer success team in Slack, and logs the win in Snowflake."
  tags:
    - sales
    - salesforce
    - jira
    - slack
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: deal-ops
      port: 8080
      tools:
        - name: process-closed-won
          description: "Given a Salesforce opportunity ID, create implementation project, notify CS team, and log in analytics."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID."
            - name: account_name
              in: body
              type: string
              description: "The account name."
            - name: deal_value
              in: body
              type: number
              description: "The deal value in USD."
          steps:
            - name: create-implementation-project
              type: call
              call: "jira.create-issue"
              with:
                project_key: "IMPL"
                issuetype: "Epic"
                summary: "Implementation: {{account_name}} — ${{deal_value}}"
            - name: notify-cs-team
              type: call
              call: "slack.post-message"
              with:
                channel: "customer-success"
                text: "New Closed Won! {{account_name}} for ${{deal_value}}. Implementation: {{create-implementation-project.key}}"
            - name: log-win
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO sales.deal_wins (opportunity_id, account_name, deal_value, won_date) VALUES ('{{opportunity_id}}', '{{account_name}}', {{deal_value}}, CURRENT_DATE())"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

When a Salesforce enterprise opportunity is closed won, creates a Jira onboarding epic for the enterprise team, updates the account record, and notifies the account manager in Slack.

naftiko: "0.5"
info:
  label: "Salesforce Enterprise Deal Closed Won"
  description: "When a Salesforce enterprise opportunity is closed won, creates a Jira onboarding epic for the enterprise team, updates the account record, and notifies the account manager in Slack."
  tags:
    - sales
    - crm
    - salesforce
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: enterprise-sales
      port: 8080
      tools:
        - name: handle-enterprise-deal-won
          description: "Given a Salesforce opportunity ID closed won, update the account, create a Jira enterprise onboarding epic, and notify the account manager in Slack."
          inputParameters:
            - name: opportunity_id
              in: body
              type: string
              description: "The Salesforce opportunity ID that was closed won."
            - name: account_id
              in: body
              type: string
              description: "The Salesforce account ID of the customer."
            - name: am_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: update-account
              type: call
              call: "salesforce.update-account"
              with:
                account_id: "{{account_id}}"
                type: "Customer"
            - name: create-onboarding-epic
              type: call
              call: "jira-sales.create-issue"
              with:
                project_key: "ENT"
                issuetype: "Epic"
                summary: "Enterprise Onboarding: {{get-opportunity.account_name}} — {{get-opportunity.name}}"
                description: "ARR: {{get-opportunity.amount}}\nClose date: {{get-opportunity.close_date}}"
            - name: notify-am
              type: call
              call: "slack-sales.post-message"
              with:
                channel: "{{am_slack_id}}"
                text: "Deal closed! {{get-opportunity.account_name}} — ARR: ${{get-opportunity.amount}} | Onboarding epic: {{create-onboarding-epic.key}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: opportunities
          path: "/sobjects/Opportunity/{{opportunity_id}}"
          inputParameters:
            - name: opportunity_id
              in: path
          operations:
            - name: get-opportunity
              method: GET
        - name: accounts
          path: "/sobjects/Account/{{account_id}}"
          inputParameters:
            - name: account_id
              in: path
          operations:
            - name: update-account
              method: PATCH
    - type: http
      namespace: jira-sales
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-sales
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Pulls Salesforce pipeline data, syncs it to Snowflake for analytics, and posts a weekly pipeline summary to the sales leadership Slack channel.

naftiko: "0.5"
info:
  label: "Salesforce Pipeline Forecast Sync"
  description: "Pulls Salesforce pipeline data, syncs it to Snowflake for analytics, and posts a weekly pipeline summary to the sales leadership Slack channel."
  tags:
    - sales
    - salesforce
    - snowflake
    - slack
capability:
  exposes:
    - type: mcp
      namespace: pipeline-ops
      port: 8080
      tools:
        - name: sync-pipeline-forecast
          description: "Given a fiscal quarter, pull pipeline data from Salesforce, sync to Snowflake, and post summary."
          inputParameters:
            - name: fiscal_quarter
              in: body
              type: string
              description: "The fiscal quarter (e.g., Q1-2026)."
          steps:
            - name: query-pipeline
              type: call
              call: "salesforce.query-records"
              with:
                q: "SELECT StageName, COUNT(Id), SUM(Amount) FROM Opportunity WHERE FiscalQuarter='{{fiscal_quarter}}' AND IsClosed=false GROUP BY StageName"
            - name: sync-to-snowflake
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO sales.pipeline_snapshots (quarter, snapshot_data, snapshot_at) VALUES ('{{fiscal_quarter}}', '{{query-pipeline.records}}', CURRENT_TIMESTAMP())"
            - name: post-summary
              type: call
              call: "slack.post-message"
              with:
                channel: "sales-leadership"
                text: "Pipeline forecast for {{fiscal_quarter}}:\n{{query-pipeline.records}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: query
          path: "/query"
          operations:
            - name: query-records
              method: GET
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a critical vulnerability is detected by CrowdStrike, creates a Jira security ticket, assigns it to the owning team via GitHub CODEOWNERS, and posts an alert to the security Slack channel.

naftiko: "0.5"
info:
  label: "Security Vulnerability Remediation Tracker"
  description: "When a critical vulnerability is detected by CrowdStrike, creates a Jira security ticket, assigns it to the owning team via GitHub CODEOWNERS, and posts an alert to the security Slack channel."
  tags:
    - security
    - crowdstrike
    - jira
    - github
    - slack
capability:
  exposes:
    - type: mcp
      namespace: vuln-remediation
      port: 8080
      tools:
        - name: track-vulnerability-remediation
          description: "Given a CrowdStrike vulnerability ID and affected service, create a Jira ticket, look up the owning team from GitHub, and alert the security channel."
          inputParameters:
            - name: vulnerability_id
              in: body
              type: string
              description: "The CrowdStrike vulnerability ID."
            - name: affected_service
              in: body
              type: string
              description: "The service or repository affected."
            - name: severity
              in: body
              type: string
              description: "Severity: critical, high, medium."
          steps:
            - name: get-codeowners
              type: call
              call: "github.get-file-contents"
              with:
                repo: "{{affected_service}}"
                path: "CODEOWNERS"
            - name: create-security-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "SEC"
                issuetype: "Bug"
                summary: "[{{severity}}] Vulnerability {{vulnerability_id}} in {{affected_service}}"
                description: "CrowdStrike detected vulnerability {{vulnerability_id}}. Owners: {{get-codeowners.content}}"
                priority: "{{severity}}"
            - name: alert-security
              type: call
              call: "slack.post-message"
              with:
                channel: "security-alerts"
                text: "Vulnerability {{vulnerability_id}} ({{severity}}) in {{affected_service}}. Jira: {{create-security-ticket.key}}. Owners: {{get-codeowners.content}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: contents
          path: "/repos/uber/{{repo}}/contents/{{path}}"
          inputParameters:
            - name: repo
              in: path
            - name: path
              in: path
          operations:
            - name: get-file-contents
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves email delivery statistics from SendGrid for a given date range.

naftiko: "0.5"
info:
  label: "SendGrid Email Delivery Stats"
  description: "Retrieves email delivery statistics from SendGrid for a given date range."
  tags:
    - communications
    - sendgrid
    - analytics
capability:
  exposes:
    - type: mcp
      namespace: email-ops
      port: 8080
      tools:
        - name: get-email-stats
          description: "Given a date range, return email delivery, bounce, and open rates from SendGrid."
          inputParameters:
            - name: start_date
              in: body
              type: string
              description: "Start date in YYYY-MM-DD format."
          call: "sendgrid-stats.get-global-stats"
          with:
            start_date: "{{start_date}}"
          outputParameters:
            - name: delivered
              type: number
              mapping: "$.stats[0].metrics.delivered"
            - name: bounces
              type: number
              mapping: "$.stats[0].metrics.bounces"
  consumes:
    - type: http
      namespace: sendgrid-stats
      baseUri: "https://api.sendgrid.com/v3"
      authentication:
        type: bearer
        token: "$secrets.sendgrid_api_key"
      resources:
        - name: stats
          path: "/stats"
          operations:
            - name: get-global-stats
              method: GET

When a microservice is scheduled for deprecation, notifies dependent teams via Slack, creates Jira migration tickets for each consumer, and updates the Confluence service catalog.

naftiko: "0.5"
info:
  label: "Service Deprecation Notifier"
  description: "When a microservice is scheduled for deprecation, notifies dependent teams via Slack, creates Jira migration tickets for each consumer, and updates the Confluence service catalog."
  tags:
    - engineering
    - slack
    - jira
    - confluence
capability:
  exposes:
    - type: mcp
      namespace: service-lifecycle
      port: 8080
      tools:
        - name: notify-service-deprecation
          description: "Given a service name, deprecation date, and list of dependent teams, create migration tickets and notify all consumers."
          inputParameters:
            - name: service_name
              in: body
              type: string
              description: "The service being deprecated."
            - name: deprecation_date
              in: body
              type: string
              description: "Deprecation date in YYYY-MM-DD format."
            - name: replacement_service
              in: body
              type: string
              description: "The replacement service name."
          steps:
            - name: create-migration-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "ENG"
                issuetype: "Epic"
                summary: "Migrate from {{service_name}} to {{replacement_service}} by {{deprecation_date}}"
            - name: update-service-catalog
              type: call
              call: "confluence.update-page"
              with:
                page_id: "service-catalog-{{service_name}}"
                body: "DEPRECATED: This service will be removed on {{deprecation_date}}. Migrate to {{replacement_service}}."
            - name: announce-deprecation
              type: call
              call: "slack.post-message"
              with:
                channel: "engineering-announcements"
                text: "SERVICE DEPRECATION: {{service_name}} will be deprecated on {{deprecation_date}}. Migrate to {{replacement_service}}. Migration epic: {{create-migration-ticket.key}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: confluence
      baseUri: "https://uber.atlassian.net/wiki/rest/api"
      authentication:
        type: basic
        username: "$secrets.confluence_user"
        password: "$secrets.confluence_api_token"
      resources:
        - name: pages
          path: "/content/{{page_id}}"
          inputParameters:
            - name: page_id
              in: path
          operations:
            - name: update-page
              method: PUT
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an SLA breach is detected, updates the Salesforce case, sends an apology email via SendGrid, and alerts the customer success team in Slack.

naftiko: "0.5"
info:
  label: "SLA Breach Customer Notification"
  description: "When an SLA breach is detected, updates the Salesforce case, sends an apology email via SendGrid, and alerts the customer success team in Slack."
  tags:
    - customer-success
    - salesforce
    - sendgrid
    - slack
capability:
  exposes:
    - type: mcp
      namespace: sla-ops
      port: 8080
      tools:
        - name: handle-sla-breach
          description: "Given an SLA breach case, update Salesforce, send customer notification, and alert CS team."
          inputParameters:
            - name: case_id
              in: body
              type: string
              description: "Salesforce case ID."
            - name: customer_email
              in: body
              type: string
              description: "Customer email address."
            - name: sla_type
              in: body
              type: string
              description: "Type of SLA breached."
          steps:
            - name: update-case
              type: call
              call: "salesforce.update-case"
              with:
                case_id: "{{case_id}}"
                SLA_Breach__c: true
            - name: send-notification
              type: call
              call: "sendgrid.send-email"
              with:
                to: "{{customer_email}}"
                subject: "Service update regarding your case"
                body: "We apologize for the delay in resolving your case {{case_id}}. Our team is prioritizing this and will provide an update within 4 hours."
            - name: alert-cs-team
              type: call
              call: "slack.post-message"
              with:
                channel: "customer-success-alerts"
                text: "SLA breach: Case {{case_id}} ({{sla_type}}). Customer notified: {{customer_email}}"
  consumes:
    - type: http
      namespace: salesforce
      baseUri: "https://uber.my.salesforce.com/services/data/v58.0"
      authentication:
        type: bearer
        token: "$secrets.salesforce_token"
      resources:
        - name: cases
          path: "/sobjects/Case/{{case_id}}"
          inputParameters:
            - name: case_id
              in: path
          operations:
            - name: update-case
              method: PATCH
    - type: http
      namespace: sendgrid
      baseUri: "https://api.sendgrid.com/v3"
      authentication:
        type: bearer
        token: "$secrets.sendgrid_api_key"
      resources:
        - name: mail
          path: "/mail/send"
          operations:
            - name: send-email
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves usage metrics for a given Slack channel including message count, active members, and last activity timestamp.

naftiko: "0.5"
info:
  label: "Slack Channel Usage Audit"
  description: "Retrieves usage metrics for a given Slack channel including message count, active members, and last activity timestamp."
  tags:
    - communications
    - slack
capability:
  exposes:
    - type: mcp
      namespace: comms-audit
      port: 8080
      tools:
        - name: get-channel-usage
          description: "Given a Slack channel ID, return message volume, active member count, and last activity date. Use for workspace cleanup and channel consolidation efforts."
          inputParameters:
            - name: channel_id
              in: body
              type: string
              description: "The Slack channel ID."
          call: "slack-analytics.get-channel-info"
          with:
            channel: "{{channel_id}}"
          outputParameters:
            - name: message_count
              type: number
              mapping: "$.channel.num_members"
            - name: last_activity
              type: string
              mapping: "$.channel.updated"
  consumes:
    - type: http
      namespace: slack-analytics
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: channels
          path: "/conversations.info"
          operations:
            - name: get-channel-info
              method: GET

When a Datadog SLO burn rate exceeds the fast-burn threshold, creates a Jira incident for the on-call team and posts an urgent Slack alert to the engineering channel.

naftiko: "0.5"
info:
  label: "SLO Burn Rate Alert"
  description: "When a Datadog SLO burn rate exceeds the fast-burn threshold, creates a Jira incident for the on-call team and posts an urgent Slack alert to the engineering channel."
  tags:
    - observability
    - slo
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: slo-ops
      port: 8080
      tools:
        - name: handle-slo-burn-alert
          description: "Given a Datadog SLO ID and current burn rate, create a Jira incident for the on-call team and post an urgent Slack alert with error budget context."
          inputParameters:
            - name: slo_id
              in: body
              type: string
              description: "The Datadog SLO ID experiencing fast burn."
            - name: slo_name
              in: body
              type: string
              description: "Human-readable name of the SLO."
            - name: burn_rate
              in: body
              type: number
              description: "Current burn rate multiplier (e.g., 14.4 for fast burn)."
            - name: error_budget_remaining_pct
              in: body
              type: number
              description: "Remaining error budget as a percentage."
            - name: eng_channel
              in: body
              type: string
              description: "Slack channel for the engineering on-call team."
          steps:
            - name: create-incident-ticket
              type: call
              call: "jira-slo.create-issue"
              with:
                project_key: "OPS"
                issuetype: "Incident"
                summary: "SLO Fast Burn: {{slo_name}} — {{burn_rate}}x burn rate"
                description: "SLO: {{slo_id}}\nBurn rate: {{burn_rate}}x\nError budget remaining: {{error_budget_remaining_pct}}%"
            - name: post-slack-alert
              type: call
              call: "slack-slo.post-message"
              with:
                channel: "{{eng_channel}}"
                text: "SLO BURN ALERT: {{slo_name}} | Burn rate: {{burn_rate}}x | Error budget remaining: {{error_budget_remaining_pct}}% | Jira: {{create-incident-ticket.key}}"
  consumes:
    - type: http
      namespace: jira-slo
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-slo
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Monitors Snowflake data pipeline execution history for the Rides and Eats analytics domains, alerts on failures via Slack, and creates Jira remediation tasks.

naftiko: "0.5"
info:
  label: "Snowflake Analytics Pipeline Monitoring"
  description: "Monitors Snowflake data pipeline execution history for the Rides and Eats analytics domains, alerts on failures via Slack, and creates Jira remediation tasks."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: analytics-monitoring
      port: 8080
      tools:
        - name: monitor-analytics-pipelines
          description: "Given a Snowflake database and pipeline prefix, check recent execution history for failures or anomalies, create a Jira remediation task for failures, and post a status digest to Slack."
          inputParameters:
            - name: database_name
              in: body
              type: string
              description: "Snowflake database containing the analytics pipelines (e.g., ANALYTICS_RIDES)."
            - name: pipeline_prefix
              in: body
              type: string
              description: "Pipeline name prefix to filter (e.g., trips_, eats_orders_)."
            - name: data_channel
              in: body
              type: string
              description: "Slack channel for the data engineering team."
          steps:
            - name: check-pipeline-runs
              type: call
              call: "snowflake-analytics.query-runs"
              with:
                database: "{{database_name}}"
                prefix: "{{pipeline_prefix}}"
            - name: create-remediation-task
              type: call
              call: "jira-analytics.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Pipeline failure: {{database_name}}.{{pipeline_prefix}}* — {{check-pipeline-runs.failed_count}} failed runs"
                description: "Database: {{database_name}}\nFailed pipelines: {{check-pipeline-runs.failed_pipelines}}"
            - name: post-status-digest
              type: call
              call: "slack-analytics.post-message"
              with:
                channel: "{{data_channel}}"
                text: "Pipeline Monitor: {{database_name}}.{{pipeline_prefix}}* | Success: {{check-pipeline-runs.success_count}} | Failed: {{check-pipeline-runs.failed_count}} | Jira: {{create-remediation-task.key}}"
  consumes:
    - type: http
      namespace: snowflake-analytics
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: query-runs
              method: POST
    - type: http
      namespace: jira-analytics
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-analytics
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Runs data quality checks against Snowflake tables and creates a Jira data quality issue when row count anomalies or null rate thresholds are exceeded, posting a summary to Slack.

naftiko: "0.5"
info:
  label: "Snowflake Data Quality Alert"
  description: "Runs data quality checks against Snowflake tables and creates a Jira data quality issue when row count anomalies or null rate thresholds are exceeded, posting a summary to Slack."
  tags:
    - data
    - analytics
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: data-quality
      port: 8080
      tools:
        - name: check-data-quality
          description: "Given a Snowflake table name and quality thresholds, execute quality checks, create a Jira issue for failures, and post a quality digest to the data engineering Slack channel."
          inputParameters:
            - name: table_name
              in: body
              type: string
              description: "The fully qualified Snowflake table name (e.g., ANALYTICS.RIDES.TRIP_EVENTS)."
            - name: null_rate_threshold
              in: body
              type: number
              description: "Maximum acceptable null rate as a percentage (e.g., 5.0 for 5%)."
            - name: data_channel
              in: body
              type: string
              description: "Slack channel for the data engineering team."
          steps:
            - name: run-quality-check
              type: call
              call: "snowflake.query-quality"
              with:
                table: "{{table_name}}"
                null_threshold: "{{null_rate_threshold}}"
            - name: create-quality-issue
              type: call
              call: "jira-quality.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "Data quality failure: {{table_name}}"
                description: "Null rate: {{run-quality-check.null_rate}}% (threshold: {{null_rate_threshold}}%). Rows: {{run-quality-check.row_count}}"
            - name: post-quality-digest
              type: call
              call: "slack-quality.post-message"
              with:
                channel: "{{data_channel}}"
                text: "Data Quality: {{table_name}} | Null rate: {{run-quality-check.null_rate}}% | Rows: {{run-quality-check.row_count}} | Status: {{run-quality-check.status}} | Jira: {{create-quality-issue.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: query-quality
              method: POST
    - type: http
      namespace: jira-quality
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack-quality
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When a Snowflake ETL pipeline fails, creates a PagerDuty incident, logs the failure in Jira, and posts a diagnostic summary to the data engineering Slack channel.

naftiko: "0.5"
info:
  label: "Snowflake ETL Failure Recovery"
  description: "When a Snowflake ETL pipeline fails, creates a PagerDuty incident, logs the failure in Jira, and posts a diagnostic summary to the data engineering Slack channel."
  tags:
    - data-engineering
    - snowflake
    - pagerduty
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: etl-recovery
      port: 8080
      tools:
        - name: handle-etl-failure
          description: "Given a failed pipeline name and error details, page the data team, create a Jira ticket, and notify Slack."
          inputParameters:
            - name: pipeline_name
              in: body
              type: string
              description: "The name of the failed ETL pipeline."
            - name: error_message
              in: body
              type: string
              description: "The error message from the failure."
            - name: affected_tables
              in: body
              type: string
              description: "Comma-separated list of affected Snowflake tables."
          steps:
            - name: page-data-team
              type: call
              call: "pagerduty.create-incident"
              with:
                title: "ETL Failure: {{pipeline_name}}"
                service_id: "DATA_ENG_SERVICE"
                body: "Pipeline {{pipeline_name}} failed. Error: {{error_message}}. Tables: {{affected_tables}}"
            - name: create-incident-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "DATA"
                issuetype: "Bug"
                summary: "ETL failure: {{pipeline_name}}"
                description: "Error: {{error_message}}\nAffected tables: {{affected_tables}}"
                priority: "High"
            - name: notify-data-eng
              type: call
              call: "slack.post-message"
              with:
                channel: "data-engineering-alerts"
                text: "ETL FAILURE: {{pipeline_name}}\nError: {{error_message}}\nTables: {{affected_tables}}\nPD: {{page-data-team.incident.id}} | Jira: {{create-incident-ticket.key}}"
  consumes:
    - type: http
      namespace: pagerduty
      baseUri: "https://api.pagerduty.com"
      authentication:
        type: apikey
        key: "Authorization"
        value: "$secrets.pagerduty_token"
        placement: header
      resources:
        - name: incidents
          path: "/incidents"
          operations:
            - name: create-incident
              method: POST
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Checks the execution status and runtime of a Snowflake query by statement handle.

naftiko: "0.5"
info:
  label: "Snowflake Query Execution Status"
  description: "Checks the execution status and runtime of a Snowflake query by statement handle."
  tags:
    - data
    - snowflake
    - analytics
capability:
  exposes:
    - type: mcp
      namespace: data-ops
      port: 8080
      tools:
        - name: get-query-status
          description: "Given a Snowflake statement handle, return execution status, row count, and elapsed time. Use for pipeline monitoring and debugging long-running queries."
          inputParameters:
            - name: statement_handle
              in: body
              type: string
              description: "The Snowflake SQL statement handle."
          call: "snowflake-sql.get-statement-status"
          with:
            statementHandle: "{{statement_handle}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.statementStatusUrl"
            - name: row_count
              type: number
              mapping: "$.resultSetMetaData.numRows"
  consumes:
    - type: http
      namespace: snowflake-sql
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements/{{statementHandle}}"
          inputParameters:
            - name: statementHandle
              in: path
          operations:
            - name: get-statement-status
              method: GET

Retrieves credit consumption and query volume for a Snowflake warehouse.

naftiko: "0.5"
info:
  label: "Snowflake Warehouse Usage Lookup"
  description: "Retrieves credit consumption and query volume for a Snowflake warehouse."
  tags:
    - data
    - snowflake
    - finops
capability:
  exposes:
    - type: mcp
      namespace: data-finops
      port: 8080
      tools:
        - name: get-warehouse-usage
          description: "Given a Snowflake warehouse name, return credit consumption and query count for the current day."
          inputParameters:
            - name: warehouse_name
              in: body
              type: string
              description: "The Snowflake warehouse name."
          call: "snowflake-usage.execute-statement"
          with:
            statement: "SELECT SUM(credits_used) as credits, COUNT(*) as queries FROM snowflake.account_usage.warehouse_metering_history WHERE warehouse_name='{{warehouse_name}}' AND start_time>=CURRENT_DATE()"
          outputParameters:
            - name: credits_used
              type: number
              mapping: "$.data[0][0]"
            - name: query_count
              type: number
              mapping: "$.data[0][1]"
  consumes:
    - type: http
      namespace: snowflake-usage
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

When a supply-demand imbalance is detected in a market, queries Snowflake for real-time metrics, creates a Jira operations ticket, and alerts the marketplace ops Slack channel.

naftiko: "0.5"
info:
  label: "Supply Demand Imbalance Responder"
  description: "When a supply-demand imbalance is detected in a market, queries Snowflake for real-time metrics, creates a Jira operations ticket, and alerts the marketplace ops Slack channel."
  tags:
    - marketplace
    - snowflake
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: marketplace-ops
      port: 8080
      tools:
        - name: respond-to-imbalance
          description: "Given a market and imbalance type, query supply-demand metrics, create an ops ticket, and alert the team."
          inputParameters:
            - name: market
              in: body
              type: string
              description: "The market/city."
            - name: imbalance_type
              in: body
              type: string
              description: "Type: undersupply or oversupply."
            - name: magnitude
              in: body
              type: number
              description: "Severity magnitude percentage."
          steps:
            - name: query-metrics
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "SELECT available_drivers, active_riders, eta_p50, surge_multiplier FROM marketplace.realtime_metrics WHERE market='{{market}}' ORDER BY timestamp DESC LIMIT 1"
            - name: create-ops-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "MKTPLACE"
                issuetype: "Task"
                summary: "{{imbalance_type}} in {{market}} ({{magnitude}}%)"
                description: "Metrics: {{query-metrics.data}}"
            - name: alert-marketplace-ops
              type: call
              call: "slack.post-message"
              with:
                channel: "marketplace-ops"
                text: "Supply-demand imbalance in {{market}}: {{imbalance_type}} at {{magnitude}}%. Metrics: {{query-metrics.data}}. Ticket: {{create-ops-ticket.key}}"
  consumes:
    - type: http
      namespace: snowflake
      baseUri: "https://uber.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: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When Terraform drift is detected, creates a Jira ticket for the infrastructure team, triggers a plan run in Terraform Cloud, and alerts the platform engineering Slack channel.

naftiko: "0.5"
info:
  label: "Terraform Drift Detection Remediation"
  description: "When Terraform drift is detected, creates a Jira ticket for the infrastructure team, triggers a plan run in Terraform Cloud, and alerts the platform engineering Slack channel."
  tags:
    - infrastructure
    - terraform
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: infra-drift
      port: 8080
      tools:
        - name: remediate-drift
          description: "Given a Terraform workspace and drift details, create a Jira ticket, trigger a plan, and notify the team."
          inputParameters:
            - name: workspace_name
              in: body
              type: string
              description: "The Terraform Cloud workspace name."
            - name: drift_description
              in: body
              type: string
              description: "Description of the detected drift."
          steps:
            - name: create-drift-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "INFRA"
                issuetype: "Bug"
                summary: "Terraform drift detected: {{workspace_name}}"
                description: "{{drift_description}}"
            - name: trigger-plan
              type: call
              call: "terraform.create-run"
              with:
                workspace_name: "{{workspace_name}}"
                message: "Automated drift detection plan for {{create-drift-ticket.key}}"
            - name: notify-platform-eng
              type: call
              call: "slack.post-message"
              with:
                channel: "platform-engineering"
                text: "Terraform drift in {{workspace_name}}. Jira: {{create-drift-ticket.key}}. Plan triggered: {{trigger-plan.data.id}}. Details: {{drift_description}}"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: 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_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

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

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

Retrieves the total resource count and workspace status from a Terraform Cloud workspace.

naftiko: "0.5"
info:
  label: "Terraform State Resource Count"
  description: "Retrieves the total resource count and workspace status from a Terraform Cloud workspace."
  tags:
    - infrastructure
    - terraform
capability:
  exposes:
    - type: mcp
      namespace: infra-ops
      port: 8080
      tools:
        - name: get-workspace-resource-count
          description: "Given a Terraform Cloud workspace name, return the total managed resources and workspace health. Use for infrastructure audits."
          inputParameters:
            - name: workspace_name
              in: body
              type: string
              description: "The Terraform Cloud workspace name."
          call: "terraform-workspaces.get-workspace"
          with:
            workspace_name: "{{workspace_name}}"
          outputParameters:
            - name: resource_count
              type: number
              mapping: "$.data.attributes.resource-count"
            - name: status
              type: string
              mapping: "$.data.attributes.current-run.status"
  consumes:
    - type: http
      namespace: terraform-workspaces
      baseUri: "https://app.terraform.io/api/v2"
      authentication:
        type: bearer
        token: "$secrets.terraform_token"
      resources:
        - name: workspaces
          path: "/organizations/uber/workspaces/{{workspace_name}}"
          inputParameters:
            - name: workspace_name
              in: path
          operations:
            - name: get-workspace
              method: GET

Checks the health status of a third-party API integration endpoint and returns response time and availability metrics.

naftiko: "0.5"
info:
  label: "Third-Party API Health Monitor"
  description: "Checks the health status of a third-party API integration endpoint and returns response time and availability metrics."
  tags:
    - integrations
    - monitoring
    - datadog
capability:
  exposes:
    - type: mcp
      namespace: integration-health
      port: 8080
      tools:
        - name: check-api-health
          description: "Given a Datadog synthetic test ID, return the latest test result and response time."
          inputParameters:
            - name: test_id
              in: body
              type: string
              description: "The Datadog synthetic test ID."
          call: "datadog-synthetics.get-test-result"
          with:
            public_id: "{{test_id}}"
          outputParameters:
            - name: status
              type: string
              mapping: "$.results[0].status"
            - name: response_time_ms
              type: number
              mapping: "$.results[0].response_time"
  consumes:
    - type: http
      namespace: datadog-synthetics
      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/{{public_id}}/results"
          inputParameters:
            - name: public_id
              in: path
          operations:
            - name: get-test-result
              method: GET

When a vendor contract is within 60 days of renewal, creates a Jira procurement ticket, notifies the finance team via Slack, and logs renewal details in Snowflake.

naftiko: "0.5"
info:
  label: "Vendor Contract Renewal Workflow"
  description: "When a vendor contract is within 60 days of renewal, creates a Jira procurement ticket, notifies the finance team via Slack, and logs renewal details in Snowflake."
  tags:
    - procurement
    - jira
    - slack
    - snowflake
capability:
  exposes:
    - type: mcp
      namespace: procurement-ops
      port: 8080
      tools:
        - name: initiate-contract-renewal
          description: "Given a vendor name and contract details, create a procurement ticket, notify finance, and log the renewal."
          inputParameters:
            - name: vendor_name
              in: body
              type: string
              description: "The vendor name."
            - name: contract_value
              in: body
              type: number
              description: "Annual contract value in USD."
            - name: renewal_date
              in: body
              type: string
              description: "Contract renewal date in YYYY-MM-DD format."
          steps:
            - name: create-procurement-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "PROC"
                issuetype: "Task"
                summary: "Contract renewal: {{vendor_name}} — ${{contract_value}} — {{renewal_date}}"
            - name: notify-finance
              type: call
              call: "slack.post-message"
              with:
                channel: "finance-procurement"
                text: "Contract renewal approaching: {{vendor_name}} (${{contract_value}}) renews {{renewal_date}}. Review: {{create-procurement-ticket.key}}"
            - name: log-renewal
              type: call
              call: "snowflake.execute-statement"
              with:
                statement: "INSERT INTO finance.contract_renewals (vendor, value, renewal_date, ticket_key) VALUES ('{{vendor_name}}', {{contract_value}}, '{{renewal_date}}', '{{create-procurement-ticket.key}}')"
  consumes:
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST
    - type: http
      namespace: snowflake
      baseUri: "https://uber.snowflakecomputing.com/api/v2"
      authentication:
        type: bearer
        token: "$secrets.snowflake_token"
      resources:
        - name: statements
          path: "/statements"
          operations:
            - name: execute-statement
              method: POST

Pulls DORA metrics from GitHub, deployment frequency from Datadog, and open incident count from Jira, then posts a weekly engineering health digest to Slack.

naftiko: "0.5"
info:
  label: "Weekly Engineering Metrics Digest"
  description: "Pulls DORA metrics from GitHub, deployment frequency from Datadog, and open incident count from Jira, then posts a weekly engineering health digest to Slack."
  tags:
    - engineering
    - github
    - datadog
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: eng-metrics
      port: 8080
      tools:
        - name: generate-weekly-digest
          description: "Given a team name, compile DORA metrics, deployment frequency, and incident counts into a Slack digest."
          inputParameters:
            - name: team_name
              in: body
              type: string
              description: "The engineering team name."
          steps:
            - name: get-pr-metrics
              type: call
              call: "github.search-prs"
              with:
                q: "org:uber is:pr is:merged merged:>=7daysago team-review-requested:{{team_name}}"
            - name: get-open-incidents
              type: call
              call: "jira.search-issues"
              with:
                jql: "project=INC AND status!=Done AND labels={{team_name}} AND created>=-7d"
            - name: post-digest
              type: call
              call: "slack.post-message"
              with:
                channel: "{{team_name}}-engineering"
                text: "Weekly Engineering Digest for {{team_name}}:\nPRs merged: {{get-pr-metrics.total_count}}\nOpen incidents: {{get-open-incidents.total}}"
  consumes:
    - type: http
      namespace: github
      baseUri: "https://api.github.com"
      authentication:
        type: bearer
        token: "$secrets.github_token"
      resources:
        - name: search
          path: "/search/issues"
          operations:
            - name: search-prs
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: search
          path: "/search"
          operations:
            - name: search-issues
              method: GET
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an employee leave of absence is approved, updates Okta access to limited mode, creates a Jira handoff ticket, and notifies the manager via Slack.

naftiko: "0.5"
info:
  label: "Workday Leave of Absence Processor"
  description: "When an employee leave of absence is approved, updates Okta access to limited mode, creates a Jira handoff ticket, and notifies the manager via Slack."
  tags:
    - hr
    - workday
    - okta
    - jira
    - slack
capability:
  exposes:
    - type: mcp
      namespace: hr-leave
      port: 8080
      tools:
        - name: process-leave-of-absence
          description: "Given employee details and leave dates, limit Okta access, create a handoff ticket, and notify the manager."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID."
            - name: leave_start
              in: body
              type: string
              description: "Leave start date."
            - name: leave_end
              in: body
              type: string
              description: "Expected return date."
            - name: manager_channel
              in: body
              type: string
              description: "Manager's Slack DM or team channel."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: create-handoff-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "IT"
                issuetype: "Task"
                summary: "LOA handoff: {{get-employee.full_name}} ({{leave_start}} to {{leave_end}})"
            - name: notify-manager
              type: call
              call: "slack.post-message"
              with:
                channel: "{{manager_channel}}"
                text: "LOA processed for {{get-employee.full_name}}: {{leave_start}} to {{leave_end}}. Handoff ticket: {{create-handoff-ticket.key}}"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the reporting chain and direct reports for a Workday employee.

naftiko: "0.5"
info:
  label: "Workday Org Chart Lookup"
  description: "Retrieves the reporting chain and direct reports for a Workday employee."
  tags:
    - hr
    - workday
capability:
  exposes:
    - type: mcp
      namespace: hr-org
      port: 8080
      tools:
        - name: get-org-chart
          description: "Given a Workday employee ID, return their manager, direct reports, and department. Use for org planning and stakeholder identification."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID."
          call: "workday-org.get-supervisory-org"
          with:
            worker_id: "{{employee_id}}"
          outputParameters:
            - name: manager
              type: string
              mapping: "$.manager.full_name"
            - name: direct_reports_count
              type: number
              mapping: "$.direct_reports_count"
  consumes:
    - type: http
      namespace: workday-org
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: org
          path: "/workers/{{worker_id}}/supervisoryOrganization"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-supervisory-org
              method: GET

Retrieves current headcount by business unit and employment type from Workday for payroll planning and workforce cost reporting.

naftiko: "0.5"
info:
  label: "Workday Payroll Period Snapshot"
  description: "Retrieves current headcount by business unit and employment type from Workday for payroll planning and workforce cost reporting."
  tags:
    - hr
    - payroll
    - workday
    - reporting
capability:
  exposes:
    - type: mcp
      namespace: hr-payroll
      port: 8080
      tools:
        - name: get-payroll-headcount
          description: "Returns current active headcount by business unit (Rides, Eats, Freight, Platform) and employment type from Workday. Use for payroll planning and cost center reporting."
          inputParameters:
            - name: business_unit
              in: body
              type: string
              description: "Business unit to filter by (e.g., Rides, Eats, Freight, Platform). Leave blank for all."
          call: "workday-payroll.get-workers"
          with:
            businessUnit: "{{business_unit}}"
          outputParameters:
            - name: total_count
              type: number
              mapping: "$.totalCount"
            - name: full_time_count
              type: number
              mapping: "$.fullTimeCount"
            - name: part_time_count
              type: number
              mapping: "$.partTimeCount"
  consumes:
    - type: http
      namespace: workday-payroll
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers"
          inputParameters:
            - name: businessUnit
              in: query
          operations:
            - name: get-workers
              method: GET

Initiates the semi-annual engineering performance review cycle in Workday, notifies all engineering managers to begin peer review assignments via Slack.

naftiko: "0.5"
info:
  label: "Workday Performance Review Kickoff"
  description: "Initiates the semi-annual engineering performance review cycle in Workday, notifies all engineering managers to begin peer review assignments via Slack."
  tags:
    - hr
    - performance-management
    - workday
    - slack
capability:
  exposes:
    - type: mcp
      namespace: performance-reviews
      port: 8080
      tools:
        - name: kickoff-performance-cycle
          description: "Given a review cycle name and submission deadline, launch performance review templates in Workday for all active employees and notify managers via Slack."
          inputParameters:
            - name: cycle_name
              in: body
              type: string
              description: "Name of the performance review cycle (e.g., 2026 H1 Performance Review)."
            - name: submission_deadline
              in: body
              type: string
              description: "Review submission deadline in YYYY-MM-DD format."
            - name: managers_channel
              in: body
              type: string
              description: "Slack channel for all engineering managers."
          steps:
            - name: launch-review-cycle
              type: call
              call: "workday-perf.create-review-cycle"
              with:
                cycleName: "{{cycle_name}}"
                dueDate: "{{submission_deadline}}"
            - name: notify-managers
              type: call
              call: "slack-perf.post-message"
              with:
                channel: "{{managers_channel}}"
                text: "{{cycle_name}} is now open. Please complete peer review assignments and manager assessments in Workday by {{submission_deadline}}. Cycle ID: {{launch-review-cycle.cycle_id}}"
  consumes:
    - type: http
      namespace: workday-perf
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: review-cycles
          path: "/performanceReviewCycles"
          operations:
            - name: create-review-cycle
              method: POST
    - type: http
      namespace: slack-perf
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

When an employee promotion is approved, updates Workday compensation, creates a Jira ticket for access provisioning changes, and sends a congratulations message via Slack.

naftiko: "0.5"
info:
  label: "Workday Promotion Workflow"
  description: "When an employee promotion is approved, updates Workday compensation, creates a Jira ticket for access provisioning changes, and sends a congratulations message via Slack."
  tags:
    - hr
    - workday
    - jira
    - slack
    - promotion
capability:
  exposes:
    - type: mcp
      namespace: hr-promotions
      port: 8080
      tools:
        - name: process-promotion
          description: "Given employee details and new role, update Workday, create access change ticket, and notify team."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID."
            - name: new_title
              in: body
              type: string
              description: "The new job title."
            - name: new_level
              in: body
              type: string
              description: "The new job level."
            - name: team_channel
              in: body
              type: string
              description: "The team Slack channel."
          steps:
            - name: get-employee
              type: call
              call: "workday.get-worker"
              with:
                worker_id: "{{employee_id}}"
            - name: create-access-ticket
              type: call
              call: "jira.create-issue"
              with:
                project_key: "IT"
                issuetype: "Task"
                summary: "Access update for promotion: {{get-employee.full_name}} to {{new_title}} ({{new_level}})"
            - name: congratulate-team
              type: call
              call: "slack.post-message"
              with:
                channel: "{{team_channel}}"
                text: "Congratulations to {{get-employee.full_name}} on their promotion to {{new_title}}! Well deserved!"
  consumes:
    - type: http
      namespace: workday
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: workers
          path: "/workers/{{worker_id}}"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-worker
              method: GET
    - type: http
      namespace: jira
      baseUri: "https://uber.atlassian.net/rest/api/3"
      authentication:
        type: basic
        username: "$secrets.jira_user"
        password: "$secrets.jira_api_token"
      resources:
        - name: issues
          path: "/issue"
          operations:
            - name: create-issue
              method: POST
    - type: http
      namespace: slack
      baseUri: "https://slack.com/api"
      authentication:
        type: bearer
        token: "$secrets.slack_token"
      resources:
        - name: messages
          path: "/chat.postMessage"
          operations:
            - name: post-message
              method: POST

Retrieves the current compensation plan and salary band for a Workday worker by employee ID.

naftiko: "0.5"
info:
  label: "Workday Worker Compensation Lookup"
  description: "Retrieves the current compensation plan and salary band for a Workday worker by employee ID."
  tags:
    - hr
    - workday
    - compensation
capability:
  exposes:
    - type: mcp
      namespace: hr-compensation
      port: 8080
      tools:
        - name: get-worker-compensation
          description: "Given a Workday employee ID, return their current base pay, compensation plan, and pay grade. Use for compensation review cycles and equity analysis."
          inputParameters:
            - name: employee_id
              in: body
              type: string
              description: "The Workday employee ID."
          call: "workday-comp.get-compensation"
          with:
            worker_id: "{{employee_id}}"
          outputParameters:
            - name: base_pay
              type: number
              mapping: "$.compensation.base_pay"
            - name: pay_grade
              type: string
              mapping: "$.compensation.pay_grade"
  consumes:
    - type: http
      namespace: workday-comp
      baseUri: "https://wd2-impl-services1.workday.com/ccx/api/v1"
      authentication:
        type: bearer
        token: "$secrets.workday_token"
      resources:
        - name: compensation
          path: "/workers/{{worker_id}}/compensation"
          inputParameters:
            - name: worker_id
              in: path
          operations:
            - name: get-compensation
              method: GET