import time
from dataclasses import dataclass
from typing import List

@dataclass
class InvokeMetric:
    mcp: str
    action: str
    success: bool
    duration_ms: float
    timestamp: float

class MetricsCollector:
    def __init__(self):
        self.metrics: List[InvokeMetric] = []

    def record(self, mcp, action, success, duration_ms):
        self.metrics.append(InvokeMetric(
            mcp=mcp,
            action=action,
            success=success,
            duration_ms=duration_ms,
            timestamp=time.time()
        ))

    def get_stats(self):
        if not self.metrics:
            return {}

        total = len(self.metrics)
        successful = sum(1 for m in self.metrics if m.success)
        avg_duration = sum(m.duration_ms for m in self.metrics) / total

        return {
            "total_invocations": total,
            "successful": successful,
            "failed": total - successful,
            "success_rate": successful / total,
            "avg_duration_ms": avg_duration
        }

# Usage
metrics = MetricsCollector()

start = time.time()
result = client.invoke(mcp, action, token, params)
duration_ms = (time.time() - start) * 1000

metrics.record(mcp, action, result["success"], duration_ms)

# Later
print(metrics.get_stats())

interface InvokeMetric {
  mcp: string;
  action: string;
  success: boolean;
  durationMs: number;
  timestamp: number;
}

class MetricsCollector {
  private metrics: InvokeMetric[] = [];

  record(mcp: string, action: string, success: boolean, durationMs: number): void {
    this.metrics.push({
      mcp,
      action,
      success,
      durationMs,
      timestamp: Date.now()
    });
  }

  getStats(): Record<string, any> {
    if (this.metrics.length === 0) {
      return {};
    }

    const total = this.metrics.length;
    const successful = this.metrics.filter(m => m.success).length;
    const avgDuration = this.metrics.reduce((sum, m) => sum + m.durationMs, 0) / total;

    return {
      totalInvocations: total,
      successful,
      failed: total - successful,
      successRate: successful / total,
      avgDurationMs: avgDuration
    };
  }
}

// Usage
const metrics = new MetricsCollector();

const start = Date.now();
const result = await client.invoke(mcp, action, token, params);
const durationMs = Date.now() - start;

metrics.record(mcp, action, result.status === 'success', durationMs);

// Later
console.log(metrics.getStats());