TRUST BROKER: HUMAN-MEDIATED AGENT COMMUNICATION

// Trust levels define human involvement
type TrustLevel = 
  | "full-mediation"    // Human reads/approves every message
  | "spot-check"        // Human samples conversations
  | "alert-only"        // Human notified on anomalies
  | "autonomous";       // Agents run free

type ConversationState = {
  agentA: string;
  agentB: string;
  trustLevel: TrustLevel;
  messageCount: number;
  successRate: number;
  lastReview: Date;
};

TRUST PROGRESSION

┌─────────────────────────────────────────────────┐
│ Phase 1: FULL MEDIATION (Couples Therapy Mode)  │
├─────────────────────────────────────────────────┤
│                                                  │
│  Agent A ──> [Human Reviews] ──> Agent B        │
│         ←── [Human Edits] ←──                    │
│                                                  │
│  • Every message blocked for approval           │
│  • Human can edit before delivery               │
│  • Building trust baseline                      │
│                                                  │
└─────────────────────────────────────────────────┘
          │
          │ (Good track record)
          ↓
┌─────────────────────────────────────────────────┐
│ Phase 2: SPOT CHECK (Supervision Mode)          │
├─────────────────────────────────────────────────┤
│                                                  │
│  Agent A ──────┬──> Agent B (90%)               │
│                │                                 │
│                └──> [Human Samples] (10%)       │
│                                                  │
│  • Most messages flow directly                  │
│  • Random sampling for quality                  │
│  • Sample rate adapts to performance            │
│                                                  │
└─────────────────────────────────────────────────┘
          │
          │ (High success rate)
          ↓
┌─────────────────────────────────────────────────┐
│ Phase 3: ALERT ONLY (Monitor Mode)              │
├─────────────────────────────────────────────────┤
│                                                  │
│  Agent A ────────> Agent B                      │
│                      │                           │
│                      └──> [Anomaly Detection]   │
│                              │                   │
│                              └──> Human (if bad) │
│                                                  │
│  • Real-time message flow                       │
│  • Human notified on anomalies only             │
│  • Async analysis doesn't block                 │
│                                                  │
└─────────────────────────────────────────────────┘
          │
          │ (Sustained excellence)
          ↓
┌─────────────────────────────────────────────────┐
│ Phase 4: AUTONOMOUS (Full Trust Mode)           │
├─────────────────────────────────────────────────┤
│                                                  │
│  Agent A ←──────────> Agent B                   │
│                                                  │
│  • Direct communication                         │
│  • Human can observe logs                       │
│  • Automatic demotion on issues                 │
│                                                  │
└─────────────────────────────────────────────────┘

// Full mediation: human in the loop
async function mediatedExchange(
  from: Agent, 
  to: Agent, 
  message: Message,
  human: HumanReviewer
) {
  // Agent A wants to send to Agent B
  const proposal = await from.composeMessage(message);
  
  // Human reviews before it goes through
  const decision = await human.review({
    from: from.id,
    to: to.id,
    content: proposal,
    context: getConversationHistory(from.id, to.id)
  });
  
  if (decision.approved) {
    // Optionally edit the message
    const finalMessage = decision.edited || proposal;
    await to.receive(finalMessage, from.id);
    
    // Track success
    updateTrustMetrics(from.id, to.id, "success");
  } else {
    // Log rejection for learning
    await logRejection(from.id, to.id, proposal, decision.reason);
  }
}

// Spot check: sample conversations
class SpotCheckMediator {
  private checkRate: number = 0.1; // 10% of messages
  
  async handleMessage(from: Agent, to: Agent, msg: Message) {
    const shouldCheck = Math.random() < this.checkRate;
    
    if (shouldCheck) {
      // Queue for human review
      await this.reviewQueue.add({
        from: from.id,
        to: to.id,
        message: msg,
        timestamp: Date.now()
      });
      
      // But still let it through
      await to.receive(msg, from.id);
    } else {
      // Direct delivery
      await to.receive(msg, from.id);
    }
    
    // Adjust check rate based on metrics
    this.adaptCheckRate(from.id, to.id);
  }
  
  adaptCheckRate(fromId: string, toId: string) {
    const metrics = getMetrics(fromId, toId);
    
    // More checks if quality drops
    if (metrics.successRate < 0.85) {
      this.checkRate = Math.min(1.0, this.checkRate * 1.5);
    }
    
    // Fewer checks if quality is high
    if (metrics.successRate > 0.95) {
      this.checkRate = Math.max(0.01, this.checkRate * 0.8);
    }
  }
}

// Alert only: human is notified, doesn't block
async function alertBasedMediation(
  from: Agent,
  to: Agent, 
  msg: Message
) {
  // Message goes through immediately
  const delivery = to.receive(msg, from.id);
  
  // But we analyze it async
  const analysis = analyzeMessage(msg, {
    conversationHistory: getHistory(from.id, to.id),
    agentProfiles: [from.profile, to.profile],
    recentMetrics: getRecentMetrics(from.id, to.id)
  });
  
  // Parallel: delivery and analysis
  const [result, score] = await Promise.all([delivery, analysis]);
  
  // Alert human only if suspicious
  if (score.anomalyScore > 0.7) {
    await notifyHuman({
      type: "anomaly-detected",
      from: from.id,
      to: to.id,
      message: msg,
      score: score,
      action: "review-conversation"
    });
  }
  
  return result;
}

// Durable Object per agent-pair
export class AgentPairMediator extends DurableObject {
  private history: Message[] = [];
  private trustLevel: TrustLevel = "full-mediation";
  private metrics = {
    totalMessages: 0,
    humanInterventions: 0,
    successRate: 1.0
  };
  
  async handleMessage(request: Request) {
    const { from, to, message, type } = await request.json();
    
    switch (type) {
      case "send":
        return this.mediateMessage(from, to, message);
      
      case "human-review":
        return this.handleHumanReview(message);
      
      case "update-trust":
        return this.updateTrustLevel();
      
      case "get-pending":
        return this.getPendingReviews();
    }
  }
  
  async mediateMessage(from: string, to: string, msg: Message) {
    this.history.push({ from, to, msg, timestamp: Date.now() });
    this.metrics.totalMessages++;
    
    switch (this.trustLevel) {
      case "full-mediation":
        // Block and wait for human
        await this.queueForReview(msg);
        return { status: "pending", id: msg.id };
      
      case "spot-check":
        if (Math.random() < 0.1) {
          await this.queueForReview(msg);
        }
        // Fall through - deliver anyway
        
      case "alert-only":
        const score = this.analyzeMessage(msg);
        if (score > 0.7) {
          await this.alertHuman(msg, score);
        }
        // Fall through
        
      case "autonomous":
        // Just track it
        await this.deliverMessage(to, msg);
        return { status: "delivered" };
    }
  }
  
  async updateTrustLevel() {
    const { successRate, totalMessages } = this.metrics;
    
    // Escalate trust with good track record
    if (successRate > 0.95 && totalMessages > 50) {
      if (this.trustLevel === "full-mediation") {
        this.trustLevel = "spot-check";
      } else if (this.trustLevel === "spot-check") {
        this.trustLevel = "alert-only";
      } else if (this.trustLevel === "alert-only") {
        this.trustLevel = "autonomous";
      }
    }
    
    // Deescalate on problems
    if (successRate < 0.85) {
      if (this.trustLevel === "autonomous") {
        this.trustLevel = "alert-only";
      } else if (this.trustLevel === "alert-only") {
        this.trustLevel = "spot-check";
      }
    }
    
    await this.state.storage.put("trustLevel", this.trustLevel);
  }
}

// Human review interface
interface ReviewRequest {
  id: string;
  from: string;
  to: string;
  message: Message;
  context: {
    history: Message[];
    metrics: PairMetrics;
    trustLevel: TrustLevel;
  };
}

// SSE stream of pending reviews
async function streamPendingReviews(humanId: string) {
  const stream = new ReadableStream({
    async start(controller) {
      // Get all agent-pairs this human supervises
      const pairs = await getSupvisedPairs(humanId);
      
      for (const pair of pairs) {
        const mediator = env.MEDIATOR.get(
          env.MEDIATOR.idFromName(`${pair.a}:${pair.b}`)
        );
        
        // WebSocket to each mediator DO
        const ws = await mediator.fetch("/ws");
        
        ws.addEventListener("message", (event) => {
          const review: ReviewRequest = JSON.parse(event.data);
          
          // Push to human's review queue
          controller.enqueue(
            `data: ${JSON.stringify(review)}\n\n`
          );
        });
      }
    }
  });
  
  return new Response(stream, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache"
    }
  });
}

// Human makes decision
async function submitReview(reviewId: string, decision: {
  approved: boolean;
  edited?: Message;
  feedback?: string;
}) {
  const review = await getReview(reviewId);
  const mediator = getMediatorDO(review.from, review.to);
  
  await mediator.fetch("/human-review", {
    method: "POST",
    body: JSON.stringify({ reviewId, decision })
  });
}

// Use case: AI coding assistants
// Two agents working on a codebase
// Human reviews their changes before merge

const codeReviewMediator = new AgentPairMediator({
  agentA: "backend-agent",
  agentB: "frontend-agent",
  trustLevel: "spot-check",
  rules: {
    // Auto-approve safe changes
    autoApprove: (msg) => {
      return msg.type === "comment" || 
             msg.linesChanged < 10;
    },
    // Always review breaking changes
    requireReview: (msg) => {
      return msg.breaking === true ||
             msg.linesChanged > 100 ||
             msg.files.includes("schema.ts");
    }
  }
});

// Use case: Customer service agents
// Human steps in when confidence is low

const supportMediator = new AgentPairMediator({
  agentA: "support-bot",
  agentB: "customer",
  trustLevel: "alert-only",
  rules: {
    alertHuman: (msg) => {
      return msg.sentiment === "angry" ||
             msg.confidence < 0.7 ||
             msg.topic === "refund";
    }
  }
});

// Use case: Multi-agent research
// Agents fact-check each other, human arbitrates

const researchMediator = new AgentPairMediator({
  agentA: "research-agent",
  agentB: "fact-checker",
  trustLevel: "full-mediation",
  rules: {
    requireHuman: (msg) => {
      const agreement = calculateAgreement(
        msg.researcherClaim,
        msg.factCheckerResult
      );
      return agreement < 0.8; // Conflict threshold
    }
  }
});