agents:
  incident_responder:
    provider: anthropic
    model: claude-sonnet-4
    system_prompt: |
      You are an SRE expert who:

      - Analyzes production incidents
      - Identifies root causes from logs and metrics
      - Creates runbooks for remediation
      - Documents post-mortems
    tools:
      - name: filesystem
        description: Access runbooks and configuration files
        mcp_server:
          type: local
          command: npx
          args:
            - "-y"
            - "@modelcontextprotocol/server-filesystem"
            - "/etc/kubernetes/manifests"

agents:
  ops_assistant:
    provider: openai
    model: gpt-4
    temperature: 0.2
    system_prompt: You investigate production issues and query infrastructure state.
    tools:
      - name: query_metrics
        script: "python ./tools/prometheus_query.py"
        description: "Query Prometheus for system metrics"
        parameters:
          type: object
          properties:
            query:
              type: string
              description: "PromQL query to execute"
            timerange:
              type: string
              description: "Time range (e.g., '5m', '1h', '24h')"

steps:
  - id: backup_database
    run: "python ./scripts/pg_backup.py --database ${{ inputs.db_name }}"
    with:
      retention_days: 30

  - id: run_migration
    container: migrate/migrate:latest
    command:
      - "migrate"
      - "-path=/migrations"
      - "-database=${{ secrets.DATABASE_URL }}"
      - "up"

steps:
  - id: check_health
    agent: monitor
    prompt: "Check health status of service: ${{ inputs.service_name }}"
    outputs:
      healthy: 
        type: boolean
        description: "Whether the service is healthy"
      error_rate:
        type: float
        description: "The error rate of the service"

  # Conditionally execute steps
  - id: scale_up
    condition: ${{ steps.check_health.outputs.error_rate > 0.05 }}
    run: "kubectl scale deployment ${{ inputs.service_name }} --replicas=5"

  # Break out steps into sub steps and run until a condition is met
  - id: rolling_restart
    while: ${{ steps.rolling_restart.iteration < 3 && !steps.rolling_restart.outputs.healthy }}
    steps:
      - id: restart_pod
        run: |
          kubectl rollout restart deployment/${{ inputs.service_name }}
          kubectl rollout status deployment/${{ inputs.service_name }} --timeout=300s

      - id: verify_health
        agent: monitor
        prompt: |
          Verify service health after restart:
          - Check HTTP endpoints return 200
          - Verify error rate < 1%
          - Confirm all pods are ready

          Service: ${{ inputs.service_name }}
        outputs:
          healthy: 
            type: boolean
            description: "Whether the service is healthy"
          metrics: 
            type: object
            description: "The metrics of the service"

state:
  rollback_count: 0
  deployment_status: "pending"

workflow:
  steps:
    - id: deploy_service
      run: "helm upgrade --install ${{ inputs.service }} ./charts/${{ inputs.service }}"
      updates:
        deployment_status: "${{ steps.deploy_service.output ? 'deployed' : 'failed' }}"
        
    - id: rollback_if_needed
      condition: ${{ state.deployment_status == 'failed' }}
      run: "helm rollback ${{ inputs.service }}"
      updates:
        rollback_count: "${{ state.rollback_count + 1 }}"

steps:
  - id: security_scan
    uses: ./workflows/security/container-scan.laq.yml
    with:
      image: ${{ inputs.docker_image }}
      
  - id: deploy_to_k8s
    uses: github.com/lacquerai/workflows/k8s-deploy@v1
    with:
      manifest: ${{ steps.generate_manifest.outputs.yaml }}
      namespace: production

agents:
  architect:
    provider: local
    model: claude-code
    system_prompt: |
      You are a cloud architect who designs scalable infrastructure solutions
      and creates Terraform configurations for AWS deployments.
      
  security_auditor:
    provider: anthropic
    model: claude-sonnet-4
    system_prompt: |
      You are a security engineer who audits infrastructure for vulnerabilities,
      reviews IAM policies, and ensures compliance with security best practices.

workflow:
  steps:
    - id: analyze_incident
      agent: sre_expert
      prompt: |
        Analyze this PagerDuty alert and provide structured incident data:
        
        ${{ inputs.alert_payload }}
      outputs:
        severity:
          type: string
          enum: ["low", "medium", "high", "critical"]
          description: "The severity of the incident"
        affected_services:
          type: array
          items:
            type: string
          description: "The affected services"
        remediation_steps:
          type: array
          items:
            type: string
          description: "The remediation steps"
        requires_escalation:
          type: boolean
          description: "Whether the incident requires escalation"

  outputs:
    incident_report:
      severity: ${{ steps.analyze_incident.outputs.severity }}
      services: ${{ steps.analyze_incident.outputs.affected_services }}
      next_steps: ${{ steps.analyze_incident.outputs.remediation_steps }}