import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ temperature: 0.7 });

// Approval Status
const ApprovalStatus = {
  PENDING: 'pending',
  APPROVED: 'approved',
  REJECTED: 'rejected',
  EXPIRED: 'expired'
};

// Approval Request
class ApprovalRequest {
  constructor(id, action, details, requester) {
    this.id = id;
    this.action = action;
    this.details = details;
    this.requester = requester;
    this.status = ApprovalStatus.PENDING;
    this.approver = null;
    this.comments = null;
    this.createdAt = Date.now();
    this.respondedAt = null;
  }

  approve(approver, comments = '') {
    this.status = ApprovalStatus.APPROVED;
    this.approver = approver;
    this.comments = comments;
    this.respondedAt = Date.now();
  }

  reject(approver, comments = '') {
    this.status = ApprovalStatus.REJECTED;
    this.approver = approver;
    this.comments = comments;
    this.respondedAt = Date.now();
  }

  isPending() {
    return this.status === ApprovalStatus.PENDING;
  }

  isExpired(maxAgeMs = 86400000) {
    return Date.now() - this.createdAt > maxAgeMs;
  }
}

// Approval Gate Manager
class ApprovalGate {
  constructor(config = {}) {
    this.pendingApprovals = new Map();
    this.approvalHistory = [];
    this.maxAge = config.maxAgeMs || 86400000; // 24 hours default
    this.autoExpire = config.autoExpire || false;
  }

  // Request approval for an action
  requestApproval(action, details, requester) {
    const request = new ApprovalRequest(
      `approval_${Date.now()}`,
      action,
      details,
      requester
    );

    this.pendingApprovals.set(request.id, request);
    console.log(`[Approval] Request #${request.id}: ${action}`);
    console.log(`  Details: ${JSON.stringify(details)}`);
    console.log(`  Requested by: ${requester}`);

    return request;
  }

  // Approve request
  approve(requestId, approver, comments = '') {
    const request = this.pendingApprovals.get(requestId);
    if (!request) {
      throw new Error(`Approval request ${requestId} not found`);
    }

    request.approve(approver, comments);
    this.approvalHistory.push(request);
    this.pendingApprovals.delete(requestId);

    console.log(`[Approval] Request #${requestId} APPROVED by ${approver}`);
    return request;
  }

  // Reject request
  reject(requestId, approver, comments = '') {
    const request = this.pendingApprovals.get(requestId);
    if (!request) {
      throw new Error(`Approval request ${requestId} not found`);
    }

    request.reject(approver, comments);
    this.approvalHistory.push(request);
    this.pendingApprovals.delete(requestId);

    console.log(`[Approval] Request #${requestId} REJECTED by ${approver}`);
    return request;
  }

  // Get pending approvals
  getPending(requester = null) {
    let approvals = Array.from(this.pendingApprovals.values());

    if (requester) {
      approvals = approvals.filter(a => a.requester === requester);
    }

    return approvals;
  }

  // Check and auto-expire old requests
  checkExpired() {
    if (!this.autoExpire) return;

    for (const [id, request] of this.pendingApprovals.entries()) {
      if (request.isExpired(this.maxAge)) {
        request.status = ApprovalStatus.EXPIRED;
        this.approvalHistory.push(request);
        this.pendingApprovals.delete(id);
        console.log(`[Approval] Request #${id} EXPIRED`);
      }
    }
  }

  // Get approval statistics
  getStats() {
    const history = this.approvalHistory;
    return {
      total: history.length,
      approved: history.filter(r => r.status === ApprovalStatus.APPROVED).length,
      rejected: history.filter(r => r.status === ApprovalStatus.REJECTED).length,
      expired: history.filter(r => r.status === ApprovalStatus.EXPIRED).length,
      pending: this.pendingApprovals.size
    };
  }
}

// High-risk actions requiring approval
const HIGH_RISK_ACTIONS = [
  'delete_data',
  'refund',
  'transfer_funds',
  'modify_permissions',
  'send_email',
  'execute_trade'
];

// Agent with Approval Gate
class ApprovalAgent {
  constructor(name, llm) {
    this.name = name;
    this.llm = llm;
    this.approvalGate = new ApprovalGate();
  }

  // Check if action requires approval
  requiresApproval(action) {
    return HIGH_RISK_ACTIONS.includes(action);
  }

  // Execute action with approval gate
  async executeWithApproval(action, details, requester) {
    // Check if approval is required
    if (!this.requiresApproval(action)) {
      console.log(`[${this.name}] Executing ${action} without approval`);
      return this.executeAction(action, details);
    }

    console.log(`[${this.name}] ${action} requires human approval`);

    // Request approval
    const approvalRequest = this.approvalGate.requestApproval(
      action,
      details,
      requester
    );

    // In real system, this would wait for human response
    // For demo, we simulate approval after checking
    console.log(`[${this.name}] Waiting for approval...`);

    return approvalRequest;
  }

  // Execute the actual action
  async executeAction(action, details) {
    console.log(`[${this.name}] Executing: ${action}`);

    // Simulate action execution
    const results = {
      delete_data: () => ({ success: true, deleted: details.records }),
      refund: () => ({ success: true, refundId: `REF_${Date.now()}`, amount: details.amount }),
      transfer_funds: () => ({ success: true, transactionId: `TXN_${Date.now()}`, from: details.from, to: details.to }),
      send_email: () => ({ success: true, emailId: `EMAIL_${Date.now()}`, to: details.to }),
      execute_trade: () => ({ success: true, tradeId: `TRADE_${Date.now()}`, symbol: details.symbol, quantity: details.quantity })
    };

    const executor = results[action];
    return executor ? executor() : { success: true, action };
  }

  // Process approval response
  async processApproval(requestId, approver, approved, comments) {
    const request = this.approvalGate.pendingApprovals.get(requestId);
    if (!request) {
      return { error: 'Request not found' };
    }

    if (approved) {
      this.approvalGate.approve(requestId, approver, comments);
      return await this.executeAction(request.action, request.details);
    } else {
      this.approvalGate.reject(requestId, approver, comments);
      return { rejected: true, reason: comments };
    }
  }
}

// Usage
async function demoApprovalGate() {
  const agent = new ApprovalAgent('FinanceBot', llm);

  // Non-high-risk action - no approval needed
  console.log('\n--- Action 1: Query (No Approval) ---');
  await agent.executeWithApproval('query_data', { table: 'transactions' }, 'user_1');

  // High-risk action - requires approval
  console.log('\n--- Action 2: Refund (Requires Approval) ---');
  const refundRequest = await agent.executeWithApproval(
    'refund',
    { orderId: 'ORD_123', amount: 99.99, reason: 'Customer request' },
    'support_agent'
  );

  // Simulate human approval
  console.log('\n--- Human Reviews and Approves ---');
  const result = await agent.processApproval(
    refundRequest.id,
    'manager_1',
    true,
    'Approved - valid customer complaint'
  );
  console.log('Result:', result);

  // Show statistics
  console.log('\n--- Approval Statistics ---');
  console.log(agent.approvalGate.getStats());
}

demoApprovalGate();

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ temperature: 0.7 });

// Review Status
const ReviewStatus = {
  PENDING: 'pending',
  APPROVED: 'approved',
  REVISION_REQUESTED: 'revision_requested',
  REJECTED: 'rejected'
};

// Review Request
class ReviewRequest {
  constructor(id, content, type, context = {}) {
    this.id = id;
    this.content = content;
    this.type = type; // 'text', 'code', 'email', 'report'
    this.context = context;
    this.status = ReviewStatus.PENDING;
    this.reviewer = null;
    this.feedback = null;
    this.ratings = {};
    this.createdAt = Date.now();
    this.completedAt = null;
  }

  approve(reviewer, feedback = '') {
    this.status = ReviewStatus.APPROVED;
    this.reviewer = reviewer;
    this.feedback = feedback;
    this.completedAt = Date.now();
  }

  requestRevision(reviewer, feedback) {
    this.status = ReviewStatus.REVISION_REQUESTED;
    this.reviewer = reviewer;
    this.feedback = feedback;
    this.completedAt = Date.now();
  }

  reject(reviewer, feedback) {
    this.status = ReviewStatus.REJECTED;
    this.reviewer = reviewer;
    this.feedback = feedback;
    this.completedAt = Date.now();
  }

  addRating(criterion, score, notes = '') {
    this.ratings[criterion] = { score, notes, timestamp: Date.now() };
  }

  getAverageRating() {
    const ratings = Object.values(this.ratings);
    if (ratings.length === 0) return 0;
    return ratings.reduce((sum, r) => sum + r.score, 0) / ratings.length;
  }
}

// Review Criteria
const ReviewCriteria = {
  ACCURACY: { name: 'Accuracy', weight: 0.3, description: 'Is the content factually correct?' },
  CLARITY: { name: 'Clarity', weight: 0.25, description: 'Is the content clear and easy to understand?' },
  TONE: { name: 'Tone', weight: 0.2, description: 'Is the tone appropriate?' },
  COMPLETENESS: { name: 'Completeness', weight: 0.25, description: 'Is all necessary information included?' }
};

// Review Manager
class ReviewManager {
  constructor() {
    this.pendingReviews = new Map();
    this.completedReviews = [];
    this.reviewers = new Set();
  }

  // Add reviewer
  addReviewer(reviewerId, name, expertise = []) {
    this.reviewers.add({ id: reviewerId, name, expertise });
    console.log(`[Review] Added reviewer: ${name}`);
  }

  // Submit content for review
  submitForReview(content, type, context = {}, submittedBy = 'system') {
    const request = new ReviewRequest(
      `review_${Date.now()}`,
      content,
      type,
      context
    );
    request.submittedBy = submittedBy;

    this.pendingReviews.set(request.id, request);
    console.log(`[Review] Submitted #${request.id} for ${type} review`);

    return request;
  }

  // Get pending reviews for a reviewer
  getPendingForReviewer(reviewerId) {
    return Array.from(this.pendingReviews.values())
      .filter(r => r.status === ReviewStatus.PENDING);
  }

  // Submit review
  submitReview(requestId, reviewerId, decision, feedback, ratings = {}) {
    const request = this.pendingReviews.get(requestId);
    if (!request) {
      throw new Error(`Review request ${requestId} not found`);
    }

    // Add ratings
    for (const [criterion, rating] of Object.entries(ratings)) {
      request.addRating(criterion, rating.score, rating.notes);
    }

    // Set decision
    if (decision === 'approve') {
      request.approve(reviewerId, feedback);
    } else if (decision === 'revision') {
      request.requestRevision(reviewerId, feedback);
    } else if (decision === 'reject') {
      request.reject(reviewerId, feedback);
    }

    this.completedReviews.push(request);
    this.pendingReviews.delete(requestId);

    console.log(`[Review] Completed #${requestId}: ${request.status}`);
    return request;
  }

  // Agent with auto-review for high-stakes content
  async generateWithReview(prompt, contentType, context = {}) {
    // Generate initial content
    const reviewRequest = this.submitForReview('', contentType, context);

    const chatPrompt = ChatPromptTemplate.fromTemplate(prompt);
    const chain = chatPrompt.pipe(llm).pipe(new StringOutputParser());
    const content = await chain.invoke(context);

    reviewRequest.content = content;
    console.log(`[Review] Generated ${contentType}, submitting for review`);

    return reviewRequest;
  }

  // Get review statistics
  getStats() {
    const completed = this.completedReviews;
    return {
      total: completed.length,
      approved: completed.filter(r => r.status === ReviewStatus.APPROVED).length,
      revisions: completed.filter(r => r.status === ReviewStatus.REVISION_REQUESTED).length,
      rejected: completed.filter(r => r.status === ReviewStatus.REJECTED).length,
      pending: this.pendingReviews.size,
      avgRating: completed.length > 0
        ? (completed.reduce((sum, r) => sum + r.getAverageRating(), 0) / completed.length).toFixed(2)
        : 0
    };
  }
}

// Usage
async function demoReview() {
  const reviewManager = new ReviewManager();

  // Add reviewers
  reviewManager.addReviewer('reviewer_1', 'Alice', ['technical', 'code']);
  reviewManager.addReviewer('reviewer_2', 'Bob', ['marketing', 'writing']);

  // Generate and submit for review
  console.log('\n--- Generating Marketing Email ---');
  const emailRequest = await reviewManager.generateWithReview(
    'Write a professional marketing email about our new product: {product}',
    'email',
    { product: 'AI Assistant Pro' }
  );

  // Simulate reviewer action
  console.log('\n--- Reviewer Evaluating ---');
  const result = reviewManager.submitReview(
    emailRequest.id,
    'reviewer_2',
    'approve',
    'Great email! Minor tone adjustment suggested.',
    {
      accuracy: { score: 5, notes: 'All facts correct' },
      clarity: { score: 4, notes: 'Clear message' },
      tone: { score: 4, notes: 'Professional but could be warmer' },
      completeness: { score: 5, notes: 'All key points covered' }
    }
  );

  console.log('\n--- Review Result ---');
  console.log(`Status: ${result.status}`);
  console.log(`Average Rating: ${result.getAverageRating()}/5`);
  console.log(`Feedback: ${result.feedback}`);

  console.log('\n--- Statistics ---');
  console.log(reviewManager.getStats());
}

demoReview();

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ temperature: 0.7 });

// Feedback Types
const FeedbackType = {
  RATING: 'rating',
  CORRECTION: 'correction',
  SUGGESTION: 'suggestion',
  UPVOTE: 'upvote',
  DOWNVOTE: 'downvote'
};

// Quality Ratings
const QualityRating = {
  EXCELLENT: 5,
  GOOD: 4,
  AVERAGE: 3,
  POOR: 2,
  VERY_POOR: 1
};

// Feedback Item
class Feedback {
  constructor(agentId, interactionId, type, userId) {
    this.id = `feedback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    this.agentId = agentId;
    this.interactionId = interactionId;
    this.type = type;
    this.userId = userId;
    this.content = {};
    this.createdAt = Date.now();
  }

  setRating(category, score, notes = '') {
    this.content.rating = { category, score, notes };
  }

  setCorrection(original, corrected, reason = '') {
    this.content.correction = { original, corrected, reason };
  }

  setSuggestion(suggestion, priority = 'medium') {
    this.content.suggestion = { suggestion, priority };
  }

  setVote(isPositive) {
    this.content.vote = isPositive ? 'upvote' : 'downvote';
  }
}

// Feedback Collector
class FeedbackCollector {
  constructor(agentId) {
    this.agentId = agentId;
    this.feedbackList = [];
    this.userFeedback = new Map();
    this.aggregatedMetrics = {};
  }

  // Collect rating feedback
  collectRating(interactionId, userId, category, score, notes = '') {
    const feedback = new Feedback(this.agentId, interactionId, FeedbackType.RATING, userId);
    feedback.setRating(category, score, notes);
    this.addFeedback(feedback);
    return feedback;
  }

  // Collect correction feedback
  collectCorrection(interactionId, userId, original, corrected, reason = '') {
    const feedback = new Feedback(this.agentId, interactionId, FeedbackType.CORRECTION, userId);
    feedback.setCorrection(original, corrected, reason);
    this.addFeedback(feedback);
    return feedback;
  }

  // Collect suggestion
  collectSuggestion(interactionId, userId, suggestion, priority = 'medium') {
    const feedback = new Feedback(this.agentId, interactionId, FeedbackType.SUGGESTION, userId);
    feedback.setSuggestion(suggestion, priority);
    this.addFeedback(feedback);
    return feedback;
  }

  // Collect vote
  collectVote(interactionId, userId, isPositive) {
    const feedback = new Feedback(this.agentId, interactionId, FeedbackType.UPVOTE, userId);
    feedback.setVote(isPositive);
    this.addFeedback(feedback);
    return feedback;
  }

  // Add feedback to collection
  addFeedback(feedback) {
    this.feedbackList.push(feedback);

    if (!this.userFeedback.has(feedback.userId)) {
      this.userFeedback.set(feedback.userId, []);
    }
    this.userFeedback.get(feedback.userId).push(feedback);

    console.log(`[Feedback] Collected ${feedback.type} from ${feedback.userId}`);
  }

  // Get feedback for specific interaction
  getFeedbackForInteraction(interactionId) {
    return this.feedbackList.filter(f => f.interactionId === interactionId);
  }

  // Get all feedback from user
  getFeedbackFromUser(userId) {
    return this.userFeedback.get(userId) || [];
  }

  // Aggregate feedback metrics
  computeMetrics() {
    const feedbackList = this.feedbackList;

    // Average ratings by category
    const ratingsByCategory = {};
    const corrections = feedbackList.filter(f => f.type === FeedbackType.CORRECTION);
    const suggestions = feedbackList.filter(f => f.type === FeedbackType.SUGGESTION);
    const upvotes = feedbackList.filter(f => f.content.vote === 'upvote').length;
    const downvotes = feedbackList.filter(f => f.content.vote === 'downvote').length;

    feedbackList.forEach(f => {
      if (f.type === FeedbackType.RATING && f.content.rating) {
        const { category, score } = f.content.rating;
        if (!ratingsByCategory[category]) {
          ratingsByCategory[category] = { total: 0, count: 0 };
        }
        ratingsByCategory[category].total += score;
        ratingsByCategory[category].count++;
      }
    });

    this.aggregatedMetrics = {
      totalFeedback: feedbackList.length,
      ratingsByCategory: Object.fromEntries(
        Object.entries(ratingsByCategory).map(([k, v]) => [k, (v.total / v.count).toFixed(2)])
      ),
      correctionsCount: corrections.length,
      suggestionsCount: suggestions.length,
      upvotes,
      downvotes,
      netSentiment: upvotes - downvotes,
      sentimentScore: feedbackList.length > 0
        ? (((upvotes - downvotes) / feedbackList.length) * 100).toFixed(1) + '%'
        : 'N/A'
    };

    return this.aggregatedMetrics;
  }

  // Generate improvement recommendations using LLM
  async generateImprovements() {
    const metrics = this.computeMetrics();

    const prompt = ChatPromptTemplate.fromTemplate(
      `Based on the following user feedback metrics, suggest improvements for the agent:

Metrics: {metrics}
Corrections: {corrections}

Suggest the top 3 areas for improvement:`
    );

    const chain = prompt.pipe(llm).pipe(new StringOutputParser());

    return chain.invoke({
      metrics: JSON.stringify(metrics, null, 2),
      corrections: 'See metrics.correctionsCount'
    });
  }

  // Get improvement patterns from corrections
  getCorrectionPatterns() {
    const corrections = this.feedbackList.filter(f => f.type === FeedbackType.CORRECTION);

    // Group by correction reason if available
    const patterns = {};
    corrections.forEach(c => {
      const reason = c.content.correction?.reason || 'unknown';
      if (!patterns[reason]) {
        patterns[reason] = [];
      }
      patterns[reason].push(c.content.correction);
    });

    return patterns;
  }
}

// Agent with Feedback Integration
class FeedbackAwareAgent {
  constructor(name, llm) {
    this.name = name;
    this.llm = llm;
    this.feedbackCollector = new FeedbackCollector(name);
    this.promptHistory = [];
  }

  // Generate response with feedback context
  async generateWithFeedback(prompt, context = {}) {
    // Get recent feedback for context
    const recentFeedback = this.feedbackCollector.feedbackList.slice(-10);
    const metrics = this.feedbackCollector.computeMetrics();

    // Build feedback context
    let feedbackContext = '';
    if (recentFeedback.length > 0) {
      feedbackContext = '\n\nRecent user feedback to consider:\n';
      recentFeedback.forEach(f => {
        if (f.type === FeedbackType.RATING && f.content.rating) {
          feedbackContext += `- Rating (${f.content.rating.category}): ${f.content.rating.score}/5\n`;
        } else if (f.type === FeedbackType.CORRECTION && f.content.correction) {
          feedbackContext += `- Correction: ${f.content.correction.original} -> ${f.content.correction.corrected}\n`;
        }
      });
    }

    // Enhance prompt with feedback
    const enhancedPrompt = prompt + feedbackContext;

    // Generate response
    const chatPrompt = ChatPromptTemplate.fromTemplate(enhancedPrompt);
    const chain = chatPrompt.pipe(llm).pipe(new StringOutputParser());
    const response = await chain.invoke(context);

    // Store in history
    const interactionId = `interaction_${Date.now()}`;
    this.promptHistory.push({ prompt, response, interactionId });

    return { response, interactionId };
  }

  // Get current metrics
  getMetrics() {
    return this.feedbackCollector.computeMetrics();
  }
}

// Usage
async function demoFeedbackLoop() {
  const agent = new FeedbackAwareAgent('SupportBot', llm);

  // Simulate user interactions and feedback
  console.log('\n--- Interaction 1 ---');
  const result1 = await agent.generateWithFeedback(
    'Explain how to reset password',
    { user: 'user_1' }
  );
  console.log('Response:', result1.response.substring(0, 100) + '...');

  // Collect feedback
  agent.feedbackCollector.collectRating(result1.interactionId, 'user_1', 'accuracy', 4);
  agent.feedbackCollector.collectVote(result1.interactionId, 'user_1', true);

  console.log('\n--- Interaction 2 ---');
  const result2 = await agent.generateWithFeedback(
    'Write a formal apology email',
    { user: 'user_2' }
  );
  console.log('Response:', result2.response.substring(0, 100) + '...');

  // More feedback
  agent.feedbackCollector.collectCorrection(
    result2.interactionId,
    'user_2',
    'We are sorry for the inconvenience',
    'We sincerely apologize for any inconvenience this may have caused',
    'Tone too casual for formal email'
  );

  console.log('\n--- Interaction 3 ---');
  const result3 = await agent.generateWithFeedback(
    'Summarize the meeting notes',
    { user: 'user_1' }
  );
  agent.feedbackCollector.collectRating(result3.interactionId, 'user_1', 'accuracy', 2, 'Missing key points');
  agent.feedbackCollector.collectVote(result3.interactionId, 'user_1', false);

  // Get metrics
  console.log('\n--- Feedback Metrics ---');
  const metrics = agent.getMetrics();
  console.log(metrics);

  // Get improvement suggestions
  console.log('\n--- AI Improvement Suggestions ---');
  const improvements = await agent.generateImprovements();
  console.log(improvements);
}

demoFeedbackLoop();

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ temperature: 0.7 });

// Escalation Reasons
const EscalationReason = {
  CONFIDENCE_LOW: 'confidence_low',
  SENSITIVE_TOPIC: 'sensitive_topic',
  USER_REQUEST: 'user_request',
  SAFETY_CONCERN: 'safety_concern',
  LEGAL_ISSUE: 'legal_issue',
  EXCEEDED_RETRIES: 'exceeded_retries',
  UNKNOWN_DOMAIN: 'unknown_domain',
  MANUAL_APPROVAL: 'manual_approval'
};

// Priority Levels
const EscalationPriority = {
  LOW: 1,
  NORMAL: 5,
  HIGH: 10,
  CRITICAL: 20
};

// Escalation Ticket
class EscalationTicket {
  constructor(id, reason, priority, context) {
    this.id = id;
    this.reason = reason;
    this.priority = priority;
    this.context = context;
    this.status = 'open';
    this.assignedTo = null;
    this.createdAt = Date.now();
    this.resolvedAt = null;
    this.resolution = null;
  }

  assign(agentId) {
    this.assignedTo = agentId;
    console.log(`[Escalation] Ticket #${this.id} assigned to ${agentId}`);
  }

  resolve(resolution) {
    this.status = 'resolved';
    this.resolution = resolution;
    this.resolvedAt = Date.now();
    console.log(`[Escalation] Ticket #${this.id} resolved: ${resolution}`);
  }

  getWaitingTime() {
    return Date.now() - this.createdAt;
  }
}

// Escalation Manager
class EscalationManager {
  constructor(config = {}) {
    this.openTickets = new Map();
    this.closedTickets = [];
    this.escalationRules = [];
    this.autoAssign = config.autoAssign || false;
    this.maxWaitingTime = config.maxWaitingTimeMs || 300000; // 5 minutes
  }

  // Add escalation rule
  addRule(condition, action) {
    this.escalationRules.push({ condition, action });
    console.log(`[Escalation] Added rule: ${condition.description}`);
  }

  // Check if should escalate
  shouldEscalate(context) {
    for (const rule of this.escalationRules) {
      if (rule.condition(context)) {
        return { shouldEscalate: true, action: rule.action };
      }
    }
    return { shouldEscalate: false };
  }

  // Create escalation ticket
  createTicket(reason, priority, context) {
    const ticket = new EscalationTicket(
      `ESC_${Date.now()}`,
      reason,
      priority,
      context
    );

    this.openTickets.set(ticket.id, ticket);
    console.log(`[Escalation] Created ticket #${ticket.id}: ${reason}`);

    if (this.autoAssign) {
      this.autoAssignTicket(ticket.id);
    }

    return ticket;
  }

  // Auto-assign ticket to available agent
  autoAssignTicket(ticketId) {
    const ticket = this.openTickets.get(ticketId);
    if (!ticket) return;

    // Simple round-robin assignment
    const agents = ['agent_1', 'agent_2', 'agent_3'];
    const existingAssigned = Array.from(this.openTickets.values())
      .filter(t => t.assignedTo && t.status === 'open');

    const nextIndex = existingAssigned.length % agents.length;
    ticket.assign(agents[nextIndex]);
  }

  // Resolve ticket
  resolveTicket(ticketId, resolution) {
    const ticket = this.openTickets.get(ticketId);
    if (!ticket) {
      throw new Error(`Ticket ${ticketId} not found`);
    }

    ticket.resolve(resolution);
    this.openTickets.delete(ticketId);
    this.closedTickets.push(ticket);

    return ticket;
  }

  // Get open tickets by priority
  getOpenByPriority() {
    return Array.from(this.openTickets.values())
      .sort((a, b) => b.priority - a.priority);
  }

  // Get overdue tickets
  getOverdueTickets() {
    return Array.from(this.openTickets.values())
      .filter(t => t.getWaitingTime() > this.maxWaitingTime);
  }

  // Get statistics
  getStats() {
    const open = Array.from(this.openTickets.values());
    const closed = this.closedTickets;

    return {
      open: open.length,
      closed: closed.length,
      byPriority: {
        critical: open.filter(t => t.priority >= EscalationPriority.HIGH).length,
        high: open.filter(t => t.priority === EscalationPriority.HIGH).length,
        normal: open.filter(t => t.priority === EscalationPriority.NORMAL).length,
        low: open.filter(t => t.priority <= EscalationPriority.LOW).length
      },
      overdue: open.filter(t => t.getWaitingTime() > this.maxWaitingTime).length,
      avgResolutionTime: closed.length > 0
        ? (closed.reduce((sum, t) => sum + (t.resolvedAt - t.createdAt), 0) / closed.length / 1000 / 60).toFixed(1) + ' min'
        : 'N/A'
    };
  }
}

// Agent with Escalation Capability
class EscalationAgent {
  constructor(name, llm, escalationManager) {
    this.name = name;
    this.llm = llm;
    this.escalationManager = escalationManager;
    this.confidenceThreshold = 0.7;
    this.retryCount = 0;
    this.maxRetries = 3;
  }

  // Process user request with escalation check
  async processRequest(userInput, context = {}) {
    console.log(`\n[${this.name}] Processing: ${userInput.substring(0, 50)}...`);

    // Check escalation rules first
    const escalationCheck = this.escalationManager.shouldEscalate({
      input: userInput,
      context,
      retryCount: this.retryCount
    });

    if (escalationCheck.shouldEscalate) {
      console.log(`[${this.name}] Escalation triggered: ${escalationCheck.action.reason}`);
      return this.escalate(escalationCheck.action, userInput, context);
    }

    try {
      // Attempt to generate response
      const response = await this.generateResponse(userInput, context);

      // Check confidence (simulated)
      const confidence = this.estimateConfidence(response);

      if (confidence < this.confidenceThreshold) {
        console.log(`[${this.name}] Low confidence (${confidence}), escalating...`);
        return this.escalate(
          { reason: EscalationReason.CONFIDENCE_LOW, priority: EscalationPriority.NORMAL },
          userInput,
          context
        );
      }

      this.retryCount = 0; // Reset on success
      return { success: true, response };

    } catch (error) {
      this.retryCount++;
      console.log(`[${this.name}] Error (attempt ${this.retryCount}): ${error.message}`);

      if (this.retryCount >= this.maxRetries) {
        return this.escalate(
          { reason: EscalationReason.EXCEEDED_RETRIES, priority: EscalationPriority.HIGH },
          userInput,
          context
        );
      }

      throw error;
    }
  }

  // Generate response
  async generateResponse(input, context) {
    const prompt = ChatPromptTemplate.fromTemplate(
      'Answer this user question: {input}'
    );
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    return chain.invoke({ input });
  }

  // Estimate confidence (simplified)
  estimateConfidence(response) {
    // Simple heuristic based on response length
    if (response.length < 20) return 0.3;
    if (response.length > 500) return 0.9;
    return 0.7;
  }

  // Escalate to human
  async escalate(action, input, context) {
    const ticket = this.escalationManager.createTicket(
      action.reason,
      action.priority || EscalationPriority.NORMAL,
      { input, context, agent: this.name }
    );

    // Generate human-readable summary
    const summary = await this.generateSummary(input, context);

    return {
      escalated: true,
      ticketId: ticket.id,
      reason: action.reason,
      summary,
      message: 'A human agent will review your request shortly.'
    };
  }

  // Generate summary for human agent
  async generateSummary(input, context) {
    const prompt = ChatPromptTemplate.fromTemplate(
      'Summarize this customer request for a human agent to understand: {input}'
    );
    const chain = prompt.pipe(llm).pipe(new StringOutputParser());
    return chain.invoke({ input });
  }
}

// Usage
async function demoEscalation() {
  const escalationManager = new EscalationManager({ autoAssign: true });

  // Define escalation rules
  escalationManager.addRule(
    (ctx) => ctx.input.toLowerCase().includes('refund') || ctx.input.toLowerCase().includes('lawsuit'),
    { reason: EscalationReason.SENSITIVE_TOPIC, priority: EscalationPriority.HIGH }
  );

  escalationManager.addRule(
    (ctx) => ctx.input.toLowerCase().includes('help me'),
    { reason: EscalationReason.USER_REQUEST, priority: EscalationPriority.NORMAL }
  );

  escalationManager.addRule(
    (ctx) => ctx.retryCount >= 3,
    { reason: EscalationReason.EXCEEDED_RETRIES, priority: EscalationPriority.HIGH }
  );

  const agent = new EscalationAgent('SupportBot', llm, escalationManager);

  // Test normal request
  console.log('\n=== Test 1: Normal Request ===');
  await agent.processRequest('What are your business hours?');

  // Test sensitive topic
  console.log('\n=== Test 2: Sensitive Topic ===');
  await agent.processRequest('I want to file a refund for my order');

  // Test with simulated errors (retry logic)
  console.log('\n=== Test 3: Error Recovery ===');
  agent.retryCount = 2; // Simulate previous failures
  await agent.processRequest('Tell me about your company');

  // Check escalation stats
  console.log('\n=== Escalation Statistics ===');
  console.log(escalationManager.getStats());

  // Simulate human resolution
  const openTickets = escalationManager.getOpenByPriority();
  if (openTickets.length > 0) {
    console.log('\n=== Resolving Ticket ===');
    escalationManager.resolveTicket(openTickets[0].id, 'Issue resolved by human agent');
  }
}

demoEscalation();