┌────────────────────────────────────────────────────────────────┐
│                    Agenten-Kommunikations-Komplexität          │
├────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Agenten: 5      10      20      50      100     200           │
│  Pfade:   10     45      190     1.225   4.950   19.900        │
│                                                                 │
│  └─ Lineares Wachstum wäre: 5x, 10x, 20x, 50x, 100x, 200x      │
│  └─ Tatsächlich ist es:   2x, 4,5x, 19x, 122,5x, 495x, 1.990x   │
│                                                                 │
│  Deshalb funktioniert Point-to-Point-Kommunikation nicht.      │
└────────────────────────────────────────────────────────────────┘

// Kern-Event-Typen für Agenten-Orchestrierung

interface AgentEvent {
  // Metadaten
  eventId: string;           // UUID v4
  eventType: string;         // Voll qualifiziert: agent.task.assigned
  timestamp: ISO8601;        // UTC
  version: string;           // Schema-Version: "2.1.0"
  
  // Kontext
  correlationId: string;     // Verfolgt Requests über Agenten hinweg
  causationId: string;       // Zeigt auf auslösendes Event
  sessionId: string;         // Gruppiert verwandte Events
  
  // Inhalt
  payload: unknown;          // Event-spezifische Daten
  
  // Routing
  source: AgentRef;          // Wer hat das Event emittiert
  target?: AgentRef;         // Beabsichtigter Empfänger (optional)
  priority: 'low' | 'normal' | 'high' | 'critical';
  
  // Lifecycle
  ttl?: number;             // Time-to-live in Sekunden
  retryCount: number;        // Wie oft verarbeitet
  deadline?: ISO8601;        // Wann das Event veraltet wird
}

# Konsistente Benennung ermöglicht Routing und Filterung

# Format: domain.entity.action.status
# Beispiele:

events:
  # Task-Lifecycle
  - agent.task.assigned
  - agent.task.started
  - agent.task.progress      // Zwischen-Updates
  - agent.task.completed
  - agent.task.failed
  - agent.task.cancelled
  - agent.task.expired       // TTL überschritten
  
  # Agenten-Lifecycle
  - agent.instance.started
  - agent.instance.heartbeat
  - agent.instance.stopped
  - agent.instance.crashed
  - agent.instance.scale.up
  - agent.instance.scale.down
  
  # System-Events
  - system.circuit.opened
  - system.circuit.closed
  - system.rate.limit.exceeded
  - system.cost.budget.warning
  - system.cost.budget.exceeded

// n8n Code Node: Events zu Redis Streams veröffentlichen

const Redis = require('ioredis');
const { v4: uuidv4 } = require('uuid');

const redis = new Redis({
  host: $env.REDIS_HOST,
  port: $env.REDIS_PORT,
  password: $env.REDIS_PASSWORD,
  maxRetriesPerRequest: 3
});

async function publishEvent(eventData) {
  const event = {
    eventId: uuidv4(),
    eventType: eventData.type,
    timestamp: new Date().toISOString(),
    version: '2.1.0',
    correlationId: eventData.correlationId || uuidv4(),
    causationId: eventData.causationId,
    sessionId: eventData.sessionId,
    payload: JSON.stringify(eventData.payload),
    source: JSON.stringify(eventData.source),
    target: eventData.target ? JSON.stringify(eventData.target) : null,
    priority: eventData.priority || 'normal',
    retryCount: eventData.retryCount || 0,
    deadline: eventData.deadline
  };

  // In Stream veröffentlichen mit maxlen zur Verhinderung unbegrenzten Wachstums
  const streamKey = `events:${eventData.type.split('.')[0]}`;
  await redis.xadd(
    streamKey,
    'MAXLEN', '~', 10000,  // Ungefähre maximale Länge
    '*',                   // Auto-generiere ID
    ...Object.entries(event).flat()
  );

  return event;
}

// n8n Code Node: Events mit Redis Consumer Groups konsumieren

const Redis = require('ioredis');

const redis = new Redis({
  host: $env.REDIS_HOST,
  port: $env.REDIS_PORT,
  password: $env.REDIS_PASSWORD
});

const CONSUMER_GROUP = 'writing-agents';
const CONSUMER_NAME = `writer-${$env.INSTANCE_ID || '1'}`;
const STREAM_KEY = 'events:type:agent.task.assigned';

async function consumeEvents() {
  // Stelle sicher, dass Consumer Group existiert
  try {
    await redis.xgroup('CREATE', STREAM_KEY, CONSUMER_GROUP, '$', 'MKSTREAM');
  } catch (e) {
    if (!e.message.includes('already exists')) throw e;
  }

  // Lese Events mit Timeout
  const messages = await redis.xreadgroup(
    'GROUP', CONSUMER_GROUP, CONSUMER_NAME,
    'BLOCK', 5000,  // Warte bis zu 5 Sekunden
    'COUNT', 10,    // Max 10 Nachrichten pro Batch
    'STREAMS', STREAM_KEY, '>'
  );

  // Verarbeite Nachrichten...
}

// n8n Workflow: Multi-Priority Queue System

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

const PRIORITIES = ['critical', 'high', 'normal', 'low'];
const QUEUE_TTLS = {
  critical: 60,    // 1 Minute
  high: 300,       // 5 Minuten
  normal: 3600,    // 1 Stunde
  low: 86400       // 24 Stunden
};

class PriorityQueueManager {
  constructor(redis) {
    this.redis = redis;
    this.queues = {
      critical: 'agent:queue:critical',
      high: 'agent:queue:high',
      normal: 'agent:queue:normal',
      low: 'agent:queue:low'
    };
  }

  async enqueue(task, priority = 'normal') {
    const queue = this.queues[priority] || this.queues.normal;
    const ttl = QUEUE_TTLS[priority];

    const enrichedTask = {
      ...task,
      priority,
      enqueuedAt: Date.now(),
      expiresAt: Date.now() + (ttl * 1000),
      attempts: 0
    };

    await this.redis.lpush(queue, JSON.stringify(enrichedTask));
    await this.redis.hincrby('metrics:queue-depth', priority, 1);

    return {
      taskId: enrichedTask.id,
      priority,
      queueDepth: await this.redis.llen(queue)
    };
  }

  async dequeue() {
    // Versuche jede Priorität in Reihenfolge
    for (const priority of PRIORITIES) {
      const queue = this.queues[priority];
      const task = await this.redis.rpop(queue);
      
      if (task) {
        await this.redis.hincrby('metrics:queue-depth', priority, -1);
        return {
          task: JSON.parse(task),
          priority,
          waitTime: Date.now() - JSON.parse(task).enqueuedAt
        };
      }
    }
    return null;
  }
}

// n8n Workflow: Verzögerter Task-Scheduler

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

class DelayedScheduler {
  constructor(redis) {
    this.redis = redis;
    this.delayedSet = 'agent:delayed-tasks';
    this.readyQueue = 'agent:queue:ready';
  }

  async schedule(task, executeAt) {
    const scheduledTask = {
      ...task,
      scheduledAt: Date.now(),
      executeAt: executeAt.getTime(),
      id: `delayed-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
    };

    // Füge zu sortiertem Set hinzu mit execute time als score
    await this.redis.zadd(
      this.delayedSet,
      scheduledTask.executeAt,
      JSON.stringify(scheduledTask)
    );

    return {
      scheduled: true,
      taskId: scheduledTask.id,
      executeAt: scheduledTask.executeAt,
      delayMs: scheduledTask.executeAt - Date.now()
    };
  }

  async pollAndPromote() {
    const now = Date.now();
    
    // Hole alle Tasks, die bereit sind zur Ausführung
    const readyTasks = await this.redis.zrangebyscore(
      this.delayedSet,
      '-inf',
      now,
      'WITHSCORES'
    );

    const promoted = [];

    for (let i = 0; i < readyTasks.length; i += 2) {
      const task = readyTasks[i];
      await this.redis.zrem(this.delayedSet, task);
      await this.redis.lpush(this.readyQueue, task);
      promoted.push(JSON.parse(task));
    }

    return {
      promoted: promoted.length,
      tasks: promoted.map(t => t.id)
    };
  }
}

// n8n Workflow: Saga Pattern Implementierung

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

class SagaOrchestrator {
  constructor(redis) {
    this.redis = redis;
  }

  async startSaga(sagaId, steps) {
    const saga = {
      id: sagaId,
      status: 'running',
      startedAt: Date.now(),
      steps: steps.map((step, idx) => ({
        id: `step-${idx}`,
        name: step.name,
        action: step.action,
        compensation: step.compensation,
        status: 'pending',
        input: null,
        output: null
      })),
      currentStep: 0
    };

    await this.redis.setex(
      `saga:${sagaId}`,
      3600,
      JSON.stringify(saga)
    );

    return this.executeNextStep(sagaId);
  }

  async executeNextStep(sagaId) {
    const saga = JSON.parse(await this.redis.get(`saga:${sagaId}`));
    
    if (saga.currentStep >= saga.steps.length) {
      saga.status = 'completed';
      saga.completedAt = Date.now();
      await this.redis.setex(`saga:${sagaId}`, 86400, JSON.stringify(saga));
      return { status: 'completed', saga };
    }

    const step = saga.steps[saga.currentStep];
    step.status = 'executing';
    step.startedAt = Date.now();

    try {
      const result = await this.executeAction(step.action, saga);
      step.status = 'completed';
      step.output = result;
      step.completedAt = Date.now();
      saga.currentStep++;

      await this.redis.setex(`saga:${sagaId}`, 3600, JSON.stringify(saga));
      return this.executeNextStep(sagaId);

    } catch (error) {
      step.status = 'failed';
      step.error = error.message;
      await this.compensate(saga, saga.currentStep);
      
      saga.status = 'compensated';
      saga.failedAt = Date.now();
      await this.redis.setex(`saga:${sagaId}`, 86400, JSON.stringify(saga));
      
      return { status: 'compensated', saga, error: error.message };
    }
  }

  async compensate(saga, failedStepIndex) {
    // Führe Compensation in umgekehrter Reihenfolge aus
    for (let i = failedStepIndex; i >= 0; i--) {
      const step = saga.steps[i];
      if (step.compensation && step.output) {
        try {
          await this.executeAction(step.compensation, saga);
          step.compensationStatus = 'completed';
        } catch (e) {
          step.compensationStatus = 'failed';
          await this.redis.lpush('saga:compensation-failures', JSON.stringify({
            sagaId: saga.id,
            stepId: step.id,
            error: e.message
          }));
        }
      }
    }
  }
}

// n8n Workflow: Circuit Breaker für Agenten-Aufrufe

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

class CircuitBreaker {
  constructor(redis, config) {
    this.redis = redis;
    this.config = {
      failureThreshold: config.failureThreshold || 5,
      successThreshold: config.successThreshold || 3,
      timeout: config.timeout || 60000,
      ...config
    };
    this.stateKey = `circuit:${config.name}`;
  }

  async getState() {
    const state = await this.redis.get(this.stateKey);
    if (!state) {
      return {
        status: 'CLOSED',
        failures: 0,
        successes: 0,
        lastFailureTime: null,
        openedAt: null
      };
    }
    return JSON.parse(state);
  }

  async recordSuccess() {
    const state = await this.getState();
    
    if (state.status === 'HALF_OPEN') {
      state.successes++;
      if (state.successes >= this.config.successThreshold) {
        state.status = 'CLOSED';
        state.failures = 0;
        state.successes = 0;
      }
    }
    
    await this.redis.setex(this.stateKey, 3600, JSON.stringify(state));
    return state;
  }

  async recordFailure() {
    const state = await this.getState();
    state.failures++;
    state.lastFailureTime = Date.now();

    if (state.status === 'CLOSED' && state.failures >= this.config.failureThreshold) {
      state.status = 'OPEN';
      state.openedAt = Date.now();
    }

    await this.redis.setex(this.stateKey, 3600, JSON.stringify(state));
    return state;
  }

  async canExecute() {
    const state = await this.getState();
    
    if (state.status === 'CLOSED') {
      return { allowed: true, state };
    }

    if (state.status === 'OPEN') {
      const timeOpen = Date.now() - state.openedAt;
      
      if (timeOpen > this.config.timeout) {
        state.status = 'HALF_OPEN';
        state.successes = 0;
        await this.redis.setex(this.stateKey, 3600, JSON.stringify(state));
        return { allowed: true, state, trial: true };
      }
      
      return { 
        allowed: false, 
        state,
        retryAfter: Math.ceil((this.config.timeout - timeOpen) / 1000)
      };
    }

    if (state.status === 'HALF_OPEN') {
      return { allowed: true, state, trial: true };
    }
  }

  async execute(operation) {
    const permission = await this.canExecute();
    
    if (!permission.allowed) {
      throw new Error(`Circuit breaker OPEN für ${this.config.name}. Retry nach ${permission.retryAfter}s`);
    }

    try {
      const result = await operation();
      await this.recordSuccess();
      return { result, state: permission.state, trial: permission.trial };
    } catch (error) {
      await this.recordFailure();
      throw error;
    }
  }
}

// n8n Workflow: Intelligentes Retry mit exponentiellem Backoff und Jitter

class RetryWithBackoff {
  constructor(config = {}) {
    this.maxRetries = config.maxRetries || 5;
    this.baseDelay = config.baseDelay || 1000;
    this.maxDelay = config.maxDelay || 60000;
    this.jitterFactor = config.jitterFactor || 0.3;
  }

  calculateDelay(attempt) {
    // Exponentiell: base * 2^attempt
    const exponential = this.baseDelay * Math.pow(2, attempt);
    const capped = Math.min(exponential, this.maxDelay);
    
    // Füge Jitter hinzu: ±jitterFactor
    const jitter = capped * this.jitterFactor * (Math.random() * 2 - 1);
    const finalDelay = capped + jitter;
    
    return Math.max(0, Math.floor(finalDelay));
  }

  async execute(operation, context) {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        const result = await operation();
        return {
          success: true,
          result,
          attempts: attempt + 1
        };
      } catch (error) {
        if (attempt === this.maxRetries - 1) {
          return {
            success: false,
            error: error.message,
            attempts: attempt + 1
          };
        }

        const delay = this.calculateDelay(attempt);
        await this.sleep(delay);
      }
    }
  }

  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// n8n Workflow: Dead Letter Queue Pattern

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

class DeadLetterQueue {
  constructor(redis) {
    this.redis = redis;
    this.dlqKey = 'queue:dead-letter';
    this.maxSize = 10000;
  }

  async add(event, error, context) {
    const deadEvent = {
      originalEvent: event,
      error: {
        message: error.message,
        stack: error.stack,
        code: error.code
      },
      context: {
        ...context,
        failedAt: new Date().toISOString(),
        retryCount: event.retryCount || 0
      },
      id: `dlq-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
    };

    await this.redis.zadd(
      this.dlqKey,
      Date.now(),
      JSON.stringify(deadEvent)
    );

    // Kürze auf maximale Größe
    const currentSize = await this.redis.zcard(this.dlqKey);
    if (currentSize > this.maxSize) {
      await this.redis.zremrangebyrank(this.dlqKey, 0, currentSize - this.maxSize - 1);
    }

    return deadEvent.id;
  }

  async retry(eventId) {
    const events = await this.redis.zrange(this.dlqKey, 0, -1);
    const event = events.find(e => JSON.parse(e).id === eventId);
    
    if (!event) {
      throw new Error('Event nicht in DLQ gefunden');
    }

    const parsed = JSON.parse(event);
    
    await this.redis.lpush('queue:pending-tasks', JSON.stringify({
      ...parsed.originalEvent,
      retryCount: (parsed.originalEvent.retryCount || 0) + 1,
      retryFromDLQ: true
    }));

    await this.redis.zrem(this.dlqKey, event);

    return { success: true, message: 'Event neu eingereiht' };
  }
}

// n8n Workflow: Token-Optimierungs-Strategien

class TokenOptimizer {
  constructor() {
    this.modelCosts = {
      'gpt-4o': { input: 2.50, output: 10.00, per: 1000000 },
      'gpt-4o-mini': { input: 0.15, output: 0.60, per: 1000000 },
      'claude-3-7-sonnet': { input: 3.00, output: 15.00, per: 1000000 },
      'claude-3-5-haiku': { input: 0.80, output: 4.00, per: 1000000 }
    };
  }

  // Strategie 1: Intelligente Modell-Auswahl
  selectModel(taskComplexity) {
    const selection = {
      simple: 'gpt-4o-mini',
      medium: 'claude-3-5-haiku',
      complex: 'gpt-4o',
      critical: 'claude-3-7-sonnet'
    };
    return selection[taskComplexity] || selection.medium;
  }

  // Strategie 2: Kontext-Komprimierung
  compressContext(messages, maxTokens = 4000) {
    let totalTokens = this.estimateTokens(messages);
    
    if (totalTokens <= maxTokens) {
      return messages;
    }

    // Prioritäts-Reihenfolge: system > last user > last assistant > older messages
    const systemMsgs = messages.filter(m => m.role === 'system');
    const userMsgs = messages.filter(m => m.role === 'user');
    const assistantMsgs = messages.filter(m => m.role === 'assistant');

    const compressed = [...systemMsgs];
    
    if (userMsgs.length > 0) {
      compressed.push(userMsgs[userMsgs.length - 1]);
    }
    if (assistantMsgs.length > 0) {
      compressed.push(assistantMsgs[assistantMsgs.length - 1]);
    }

    return compressed;
  }

  // Strategie 3: Response Caching
  async getCachedResponse(promptHash) {
    const cached = this.cache.get(promptHash);
    if (cached && Date.now() - cached.timestamp < 3600000) {
      return cached.response;
    }
    return null;
  }

  estimateTokens(messages) {
    const text = messages.map(m => m.content).join('');
    return Math.ceil(text.length / 4);
  }

  calculateCost(model, inputTokens, outputTokens) {
    const costs = this.modelCosts[model];
    if (!costs) return 0;
    
    const inputCost = (inputTokens / costs.per) * costs.input;
    const outputCost = (outputTokens / costs.per) * costs.output;
    
    return inputCost + outputCost;
  }
}

// n8n Workflow: Budget-basiertes Rate Limiting

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

class BudgetController {
  constructor(redis) {
    this.redis = redis;
  }

  async setBudget(scope, config) {
    const budget = {
      scope,
      maxAmount: config.maxAmount,
      currentSpend: 0,
      currency: config.currency || 'USD',
      warningThreshold: config.warningThreshold || 0.8,
      action: config.action || 'block'
    };

    const key = `budget:${scope}`;
    await this.redis.setex(key, config.ttl || 86400, JSON.stringify(budget));
    return budget;
  }

  async checkBudget(scope, estimatedCost = 0) {
    const key = `budget:${scope}`;
    const data = await this.redis.get(key);
    
    if (!data) {
      return { allowed: true, reason: 'no-budget-set' };
    }

    const budget = JSON.parse(data);
    const projectedSpend = budget.currentSpend + estimatedCost;
    const utilization = projectedSpend / budget.maxAmount;

    if (utilization >= 1.0) {
      return {
        allowed: false,
        reason: 'budget-exceeded',
        currentSpend: budget.currentSpend,
        budget: budget.maxAmount,
        action: budget.action
      };
    }

    if (utilization >= budget.warningThreshold) {
      await this.redis.publish('alerts:budget', JSON.stringify({
        scope,
        currentSpend: budget.currentSpend,
        budget: budget.maxAmount,
        utilization,
        timestamp: new Date().toISOString()
      }));
    }

    return {
      allowed: true,
      utilization,
      remaining: budget.maxAmount - budget.currentSpend
    };
  }

  async recordSpend(scope, amount) {
    const key = `budget:${scope}`;
    const data = await this.redis.get(key);
    
    if (!data) return;

    const budget = JSON.parse(data);
    budget.currentSpend += amount;
    
    await this.redis.setex(key, 86400, JSON.stringify(budget));
  }
}

// n8n Workflow: OpenTelemetry Tracing für Agenten-Systeme

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { trace, SpanStatusCode } = require('@opentelemetry/api');

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: $env.OTEL_COLLECTOR_URL
  })
});

sdk.start();
const tracer = trace.getTracer('agent-orchestrator');

class AgentTracer {
  constructor(tracer) {
    this.tracer = tracer;
  }

  async traceWorkflow(workflowId, workflowFn) {
    return this.tracer.startActiveSpan(
      `workflow:${workflowId}`,
      {
        attributes: {
          'workflow.id': workflowId,
          'workflow.type': 'agent-orchestration'
        }
      },
      async (span) => {
        try {
          const result = await workflowFn(span);
          span.setStatus({ code: SpanStatusCode.OK });
          return result;
        } catch (error) {
          span.setStatus({
            code: SpanStatusCode.ERROR,
            message: error.message
          });
          span.recordException(error);
          throw error;
        } finally {
          span.end();
        }
      }
    );
  }

  calculateCost(usage) {
    if (!usage) return 0;
    const inputCost = (usage.prompt_tokens / 1000000) * 2.50;
    const outputCost = (usage.completion_tokens / 1000000) * 10.00;
    return inputCost + outputCost;
  }
}

// n8n Workflow: Metriken-Sammlung für Dashboards

const Redis = require('ioredis');
const redis = new Redis($env.REDIS_URL);

class MetricsCollector {
  constructor(redis) {
    this.redis = redis;
  }

  async increment(counter, value = 1, labels = {}) {
    const key = `metrics:counter:${counter}:${this.serializeLabels(labels)}`;
    await this.redis.hincrby('metrics:realtime', key, value);
  }

  async timing(metric, durationMs, labels = {}) {
    await this.histogram(`${metric}_duration`, durationMs, labels);
  }

  async getDashboardData(timeRange = '1h') {
    const rangeMs = {
      '1h': 3600000,
      '6h': 21600000,
      '24h': 86400000
    }[timeRange] || 3600000;

    const counters = await this.redis.hgetall('metrics:realtime');
    
    return {
      timestamp: new Date().toISOString(),
      range: timeRange,
      agents: {
        active: parseInt(counters['metrics:counter:agent_active:{}'] || 0),
        totalTasks: parseInt(counters['metrics:counter:tasks_completed:{}'] || 0),
        failedTasks: parseInt(counters['metrics:counter:tasks_failed:{}'] || 0),
        successRate: this.calculateSuccessRate(counters)
      },
      costs: {
        total: parseFloat(counters['metrics:gauge:cost_total:{}'] || 0),
        hourly: await this.getHourlyCost()
      },
      performance: {
        avgLatency: parseFloat(counters['metrics:gauge:avg_latency:{}'] || 0),
        throughput: parseInt(counters['metrics:counter:requests_total:{}'] || 0) / (rangeMs / 1000)
      }
    };
  }

  calculateSuccessRate(counters) {
    const completed = parseInt(counters['metrics:counter:tasks_completed:{}'] || 0);
    const failed = parseInt(counters['metrics:counter:tasks_failed:{}'] || 0);
    if (completed + failed === 0) return 100;
    return ((completed / (completed + failed)) * 100).toFixed(2);
  }
}

# agent-orchestrator-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: agent-orchestrator
  namespace: ai-automation
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: agent-orchestrator
  template:
    metadata:
      labels:
        app: agent-orchestrator
        version: v2.0.0
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "9090"
    spec:
      containers:
      - name: orchestrator
        image: company/agent-orchestrator:2.0.0
        ports:
        - containerPort: 3000
          name: http
        - containerPort: 9090
          name: metrics
        env:
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: redis-credentials
              key: url
        resources:
          requests:
            memory: "512Mi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "2000m"
        livenessProbe:
          httpGet:
            path: /health/live
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health/ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: agent-orchestrator-hpa
  namespace: ai-automation
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: agent-orchestrator
  minReplicas: 3
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

# prometheus-rules.yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: agent-orchestrator-alerts
  namespace: monitoring
spec:
  groups:
  - name: agent-orchestrator
    rules:
    - alert: HighAgentFailureRate
      expr: |
        (
          sum(rate(agent_tasks_failed_total[5m]))
          /
          sum(rate(agent_tasks_total[5m]))
        ) > 0.1
      for: 5m
      labels:
        severity: warning
      annotations:
        summary: "Hohe Agenten-Fehlerrate erkannt"
        description: "Agenten-Fehlerrate ist {{ $value | humanizePercentage }} in den letzten 5m"

    - alert: BudgetExceeded
      expr: agent_daily_spend_usd > 500
      for: 1m
      labels:
        severity: critical
      annotations:
        summary: "Tägliches Budget überschritten"
        description: "Tägliche Ausgaben von ${{ $value }} überschreiten $500 Limit"

    - alert: CircuitBreakerOpen
      expr: circuit_breaker_status == 1
      for: 1m
      labels:
        severity: warning
      annotations:
        summary: "Circuit Breaker ist geöffnet"
        description: "Circuit {{ $labels.name }} ist seit >1m geöffnet"