// Conversation state management for agent UX
// 智能体用户体验的对话状态管理
import { ChatOpenAI } from "@langchain/openai";

// Conversation state
// 对话状态
interface ConversationState {
  sessionId: string;
  messages: Message[];
  context: Record<string, any>;
  userProfile?: UserProfile;
  agentState: "idle" | "thinking" | "responding" | "waiting";
  lastUpdated: number;
}

// Message structure
// 消息结构
interface Message {
  id: string;
  role: "user" | "agent" | "system";
  content: string;
  timestamp: number;
  metadata?: {
    intent?: string;
    confidence?: number;
    actions?: string[];
  };
}

// User profile
// 用户画像
interface UserProfile {
  id: string;
  preferences: {
    language: string;
    verbosity: "brief" | "normal" | "detailed";
    explanations: boolean;
  };
  history: {
    totalConversations: number;
    avgSatisfaction: number;
  };
}

// Conversation manager
// 对话管理器
class ConversationManager {
  private conversations: Map<string, ConversationState> = new Map();
  private maxHistoryLength = 50;

  // Start new conversation
  createSession(sessionId: string, userProfile?: UserProfile): ConversationState {
    const state: ConversationState = {
      sessionId,
      messages: [],
      context: {},
      userProfile,
      agentState: "idle",
      lastUpdated: Date.now()
    };

    this.conversations.set(sessionId, state);
    console.log(`[Conversation] Created session: ${sessionId}`);

    return state;
  }

  // Add message to conversation
  addMessage(
    sessionId: string,
    role: "user" | "agent" | "system",
    content: string,
    metadata?: any
  ): Message {
    const state = this.conversations.get(sessionId);
    if (!state) {
      throw new Error(`Session not found: ${sessionId}`);
    }

    const message: Message = {
      id: `msg-${Date.now()}`,
      role,
      content,
      timestamp: Date.now(),
      metadata
    };

    state.messages.push(message);
    state.lastUpdated = Date.now();

    // Trim history if needed
    if (state.messages.length > this.maxHistoryLength) {
      state.messages = state.messages.slice(-this.maxHistoryLength);
    }

    console.log(`[Conversation] Added ${role} message to session ${sessionId}`);
    return message;
  }

  // Get conversation context
  getContext(sessionId: string): ConversationState | undefined {
    return this.conversations.get(sessionId);
  }

  // Update context
  updateContext(sessionId: string, key: string, value: any): void {
    const state = this.conversations.get(sessionId);
    if (state) {
      state.context[key] = value;
      state.lastUpdated = Date.now();
    }
  }

  // Get recent messages
  getRecentMessages(sessionId: string, count: number = 10): Message[] {
    const state = this.conversations.get(sessionId);
    if (!state) return [];

    return state.messages.slice(-count);
  }

  // Set agent state
  setAgentState(sessionId: string, agentState: "idle" | "thinking" | "responding" | "waiting"): void {
    const state = this.conversations.get(sessionId);
    if (state) {
      state.agentState = agentState;
      state.lastUpdated = Date.now();
    }
  }

  // Check if session exists
  hasSession(sessionId: string): boolean {
    return this.conversations.has(sessionId);
  }

  // Get all sessions
  getAllSessions(): string[] {
    return Array.from(this.conversations.keys());
  }
}

// Example usage: 创建示例
const manager = new ConversationManager();

// Create a session
const session = manager.createSession("user-123", {
  id: "user-123",
  preferences: {
    language: "en",
    verbosity: "normal",
    explanations: true
  },
  history: {
    totalConversations: 5,
    avgSatisfaction: 4.2
  }
});

// Add messages
manager.addMessage("user-123", "user", "What's the weather today?");
manager.addMessage("user-123", "agent", "The weather today is sunny with a high of 72°F.", {
  intent: "weather_query",
  confidence: 0.95
});

console.log("Recent messages:", manager.getRecentMessages("user-123", 5));

// Explainable AI response system
// 可解释AI响应系统
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";

// Explanation types
// 解释类型
enum ExplanationType {
  DECISION = "decision",
  RECOMMENDATION = "recommendation",
  ACTION = "action",
  UNCERTAINTY = "uncertainty",
  LIMITATION = "limitation"
}

// Explanation structure
// 解释结构
interface Explanation {
  type: ExplanationType;
  title: string;
  reasoning: string;
  supportingEvidence: string[];
  confidence: number;
  alternatives?: string[];
  userFriendly: string;
}

// Explanation generator
// 解释生成器
class ExplanationGenerator {
  private llm: ChatOpenAI;

  constructor() {
    this.llm = new ChatOpenAI({ temperature: 0.3 });
  }

  // Generate explanation for a decision
  async generateExplanation(
    type: ExplanationType,
    decision: string,
    context: Record<string, any>
  ): Promise<Explanation> {
    // Generate user-friendly explanation
    const prompt = ChatPromptTemplate.fromTemplate(
      `You are an AI that explains decisions in simple, user-friendly language.
      Decision: {decision}
      Context: {context}
      Type: {type}

      Provide:
      1. A brief title (max 10 words)
      2. A simple explanation (2-3 sentences, avoid jargon)
      3. The reasoning behind the decision (3-4 bullet points)
      4. Supporting evidence or factors

      Format as JSON with keys: title, userFriendly, reasoning, supportingEvidence`
    );

    try {
      const response = await this.llm.invoke(
        await prompt.format({
          decision,
          context: JSON.stringify(context),
          type
        })
      );

      // Parse response (simplified)
      const explanation: Explanation = {
        type,
        title: `Explanation: ${decision.substring(0, 30)}...`,
        reasoning: `Based on the provided context and analysis, ${decision}`,
        supportingEvidence: Object.keys(context).slice(0, 3),
        confidence: context.confidence || 0.85,
        userFriendly: decision
      };

      // Add alternatives if applicable
      if (context.alternatives) {
        explanation.alternatives = context.alternatives;
      }

      return explanation;

    } catch (error) {
      // Fallback explanation
      return {
        type,
        title: "Decision Made",
        reasoning: "Analysis completed based on available data",
        supportingEvidence: [],
        confidence: 0.5,
        userFriendly: decision
      };
    }
  }

  // Generate uncertainty explanation
  generateUncertaintyExplanation(confidence: number, factors: string[]): Explanation {
    let message: string;
    if (confidence >= 0.8) {
      message = "I'm quite confident in this assessment.";
    } else if (confidence >= 0.6) {
      message = "I'm reasonably confident, but there are some uncertainties.";
    } else if (confidence >= 0.4) {
      message = "I'm uncertain about this - the data is mixed.";
    } else {
      message = "I don't have enough information to give a reliable answer.";
    }

    return {
      type: ExplanationType.UNCERTAINTY,
      title: "Confidence Level",
      reasoning: message,
      supportingEvidence: factors,
      confidence,
      userFriendly: message
    };
  }
}

// Response builder with explanations
// 带解释的响应构建器
class ExplainableResponseBuilder {
  private explanationGenerator: ExplanationGenerator;

  constructor() {
    this.explanationGenerator = new ExplanationGenerator();
  }

  // Build response with explanation
  async buildResponse(
    content: string,
    decision: string,
    context: Record<string, any>,
    includeExplanation: boolean = true
  ): Promise<{ content: string; explanation?: Explanation }> {
    const response: { content: string; explanation?: Explanation } = {
      content
    };

    if (includeExplanation) {
      response.explanation = await this.explanationGenerator.generateExplanation(
        ExplanationType.RECOMMENDATION,
        decision,
        context
      );
    }

    return response;
  }

  // Build response with confidence indicator
  buildResponseWithConfidence(
    content: string,
    confidence: number,
    factors: string[]
  ): { content: string; confidence: number; explanation: Explanation } {
    const explanation = this.explanationGenerator.generateUncertaintyExplanation(
      confidence,
      factors
    );

    return {
      content,
      confidence,
      explanation
    };
  }
}

// Example usage: 创建示例
const builder = new ExplainableResponseBuilder();

// Example with explanation
builder.buildResponse(
  "Based on your risk profile, I recommend a diversified portfolio with 60% stocks and 40% bonds.",
  "Recommended 60/40 portfolio allocation",
  { riskScore: 0.6, age: 35, goals: "growth" }
).then(response => {
  console.log("Response with explanation:");
  console.log("  Content:", response.content);
  console.log("  Explanation:", response.explanation?.title);
});

// Example with confidence
const confidentResponse = builder.buildResponseWithConfidence(
  "The market shows strong upward momentum based on recent trends.",
  0.85,
  ["S&P 500 up 2% this week", "Low unemployment data", "Positive earnings reports"]
);

console.log("\nResponse with confidence:");
console.log("  Content:", confidentResponse.content);
console.log("  Confidence:", confidentResponse.confidence);
console.log("  Explanation:", confidentResponse.explanation.userFriendly);

// User feedback collection system
// 用户反馈收集系统
import { ChatOpenAI } from "@langchain/openai";

// Feedback types
// 反馈类型
enum FeedbackType {
  SATISFACTION = "satisfaction",
  USABILITY = "usability",
  ACCURACY = "accuracy",
  SPEED = "speed",
  OVERALL = "overall"
}

// Feedback entry
// 反馈条目
interface FeedbackEntry {
  id: string;
  sessionId: string;
  type: FeedbackType;
  rating: number; // 1-5
  comment?: string;
  timestamp: number;
  context?: Record<string, any>;
}

// Feedback collector
// 反馈收集器
class FeedbackCollector {
  private feedback: FeedbackEntry[] = [];
  private pendingRequests: Map<string, FeedbackType[]> = new Map();

  // Request feedback from user
  requestFeedback(sessionId: string, types: FeedbackType[]): string {
    const requestId = `fb-${Date.now()}`;
    this.pendingRequests.set(requestId, types);

    console.log(`[Feedback] Requested feedback for session ${sessionId}`);
    return requestId;
  }

  // Collect feedback
  collectFeedback(
    sessionId: string,
    type: FeedbackType,
    rating: number,
    comment?: string
  ): FeedbackEntry {
    const entry: FeedbackEntry = {
      id: `feedback-${Date.now()}`,
      sessionId,
      type,
      rating: Math.min(5, Math.max(1, rating)),
      comment,
      timestamp: Date.now()
    };

    this.feedback.push(entry);
    console.log(`[Feedback] Collected ${type} feedback: ${rating}/5`);

    return entry;
  }

  // Get feedback for session
  getSessionFeedback(sessionId: string): FeedbackEntry[] {
    return this.feedback.filter(f => f.sessionId === sessionId);
  }

  // Get average ratings
  getAverageRatings(): Record<FeedbackType, number> {
    const ratings: Record<FeedbackType, { sum: number; count: number }> = {
      [FeedbackType.SATISFACTION]: { sum: 0, count: 0 },
      [FeedbackType.USABILITY]: { sum: 0, count: 0 },
      [FeedbackType.ACCURACY]: { sum: 0, count: 0 },
      [FeedbackType.SPEED]: { sum: 0, count: 0 },
      [FeedbackType.OVERALL]: { sum: 0, count: 0 }
    };

    for (const f of this.feedback) {
      ratings[f.type].sum += f.rating;
      ratings[f.type].count++;
    }

    const averages: Record<FeedbackType, number> = {} as any;
    for (const type of Object.keys(ratings) as FeedbackType[]) {
      const { sum, count } = ratings[type];
      averages[type] = count > 0 ? sum / count : 0;
    }

    return averages;
  }

  // Get NPS score
  getNPSScore(): number {
    const promoters = this.feedback.filter(f =>
      f.type === FeedbackType.OVERALL && f.rating >= 4
    ).length;
    const detractors = this.feedback.filter(f =>
      f.type === FeedbackType.OVERALL && f.rating <= 2
    ).length;
    const total = this.feedback.filter(f =>
      f.type === FeedbackType.OVERALL
    ).length;

    if (total === 0) return 0;

    return ((promoters - detractors) / total) * 100;
  }

  // Generate feedback report
  generateReport(): any {
    return {
      totalFeedback: this.feedback.length,
      averageRatings: this.getAverageRatings(),
      npsScore: this.getNPSScore(),
      recentFeedback: this.feedback.slice(-10).map(f => ({
        type: f.type,
        rating: f.rating,
        comment: f.comment
      }))
    };
  }
}

// In-conversation feedback prompts
// 对话内反馈提示
class FeedbackPrompts {
  private collector: FeedbackCollector;

  constructor(collector: FeedbackCollector) {
    this.collector = collector;
  }

  // Get appropriate feedback prompt
  getPrompt(type: FeedbackType): string {
    const prompts: Record<FeedbackType, string> = {
      [FeedbackType.SATISFACTION]: "How satisfied are you with this response?",
      [FeedbackType.USABILITY]: "Was this easy to understand?",
      [FeedbackType.ACCURACY]: "Was this information accurate?",
      [FeedbackType.SPEED]: "Was this response fast enough?",
      [FeedbackType.OVERALL]: "How would you rate your overall experience?"
    };

    return prompts[type];
  }

  // Generate rating UI description
  getRatingUI(): string {
    return "Please rate: 1 (Poor) to 5 (Excellent)";
  }

  // Handle feedback collection
  handleFeedbackResponse(
    sessionId: string,
    response: string | number,
    type: FeedbackType = FeedbackType.OVERALL
  ): FeedbackEntry | null {
    // If numeric rating
    if (typeof response === "number") {
      return this.collector.collectFeedback(sessionId, type, response);
    }

    // Parse text response (simplified)
    const positive = ["good", "great", "excellent", "satisfied", "helpful"];
    const negative = ["bad", "poor", "unsatisfied", "not helpful"];

    const lower = response.toLowerCase();
    if (positive.some(p => lower.includes(p))) {
      return this.collector.collectFeedback(sessionId, type, 4);
    } else if (negative.some(n => lower.includes(n))) {
      return this.collector.collectFeedback(sessionId, type, 2);
    }

    return null;
  }
}

// Example usage: 创建示例
const collector = new FeedbackCollector();
const prompts = new FeedbackPrompts(collector);

// Simulate feedback collection
collector.collectFeedback("session-1", FeedbackType.SATISFACTION, 5, "Very helpful!");
collector.collectFeedback("session-1", FeedbackType.ACCURACY, 4, "Mostly accurate");
collector.collectFeedback("session-2", FeedbackType.OVERALL, 5, "Excellent service");
collector.collectFeedback("session-3", FeedbackType.OVERALL, 2, "Not what I needed");

console.log("\n=== Feedback Report ===");
console.log(JSON.stringify(collector.generateReport(), null, 2));

// Accessibility features for agent interfaces
// 智能体界面的无障碍功能
import { ChatOpenAI } from "@langchain/openai";

// Accessibility preferences
// 无障碍偏好
interface AccessibilityPreferences {
  screenReader: boolean;
  highContrast: boolean;
  largeText: boolean;
  reducedMotion: boolean;
  keyboardNavigation: boolean;
  cognitiveSupport: boolean;
}

// Content formatting options
// 内容格式化选项
interface FormattingOptions {
  usePlainLanguage: boolean;
  includeSummaries: boolean;
  breakIntoSteps: boolean;
  useBullets: boolean;
  maxSentenceLength: number;
}

// Accessibility manager
// 无障碍管理器
class AccessibilityManager {
  private userPreferences: Map<string, AccessibilityPreferences> = new Map();

  // Set user preferences
  setPreferences(userId: string, preferences: Partial<AccessibilityPreferences>): void {
    const current = this.userPreferences.get(userId) || {
      screenReader: false,
      highContrast: false,
      largeText: false,
      reducedMotion: true,
      keyboardNavigation: true,
      cognitiveSupport: false
    };

    this.userPreferences.set(userId, { ...current, ...preferences });
    console.log(`[Accessibility] Updated preferences for user ${userId}`);
  }

  // Get user preferences
  getPreferences(userId: string): AccessibilityPreferences {
    return this.userPreferences.get(userId) || {
      screenReader: false,
      highContrast: false,
      largeText: false,
      reducedMotion: true,
      keyboardNavigation: true,
      cognitiveSupport: false
    };
  }

  // Format content for accessibility
  formatContent(userId: string, content: string): string {
    const prefs = this.getPreferences(userId);
    let formatted = content;

    if (prefs.usePlainLanguage || prefs.cognitiveSupport) {
      formatted = this.simplifyLanguage(formatted);
    }

    if (prefs.cognitiveSupport) {
      formatted = this.breakIntoSteps(formatted);
      formatted = this.addSummaries(formatted);
    }

    if (prefs.useBullets) {
      formatted = this.convertToBullets(formatted);
    }

    return formatted;
  }

  // Simplify language
  private simplifyLanguage(text: string): string {
    // In production, would use proper text simplification
    // 简化复杂词汇
    const simplifications: Record<string, string> = {
      "utilize": "use",
      "facilitate": "help",
      "implement": "do",
      "subsequently": "later",
      "therefore": "so",
      "however": "but",
      "additionally": "also",
      "approximately": "about"
    };

    let simplified = text;
    for (const [complex, simple] of Object.entries(simplifications)) {
      simplified = simplified.replace(new RegExp(complex, "gi"), simple);
    }

    return simplified;
  }

  // Break into steps
  private breakIntoSteps(text: string): string {
    // Split long paragraphs
    const sentences = text.split(". ");
    if (sentences.length <= 3) return text;

    // Add step markers
    return sentences.map((s, i) => {
      const step = i + 1;
      return s.trim() + (i < sentences.length - 1 ? "." : "");
    }).join("\n\n");
  }

  // Add summaries
  private addSummaries(text: string): string {
    // Add brief summary at start
    const summary = "Here's what you need to know:\n\n";
    return summary + text;
  }

  // Convert to bullets
  private convertToBullets(text: string): string {
    // Convert lists to bullet points
    return text.replace(/(\d+\.\s)/g, "- ");
  }

  // Generate ARIA labels
  generateARIAlabel(elementType: string, content: string): string {
    const prefs = this.getPreferences(""); // Default for current user
    if (!prefs.screenReader) return "";

    return `${elementType}: ${content.substring(0, 100)}`;
  }

  // Get keyboard navigation hints
  getKeyboardHints(): string[] {
    return [
      "Press Tab to navigate between elements",
      "Press Enter to select",
      "Press Escape to cancel",
      "Use arrow keys for lists"
    ];
  }
}

// Example usage: 创建示例
const accessibilityManager = new AccessibilityManager();

// Set user preferences
accessibilityManager.setPreferences("user-123", {
  cognitiveSupport: true,
  largeText: true
});

// Format content
const content = "We subsequently implemented the solution to facilitate better user experience.";
const formatted = accessibilityManager.formatContent("user-123", content);

console.log("\n=== Accessibility Formatting ===");
console.log("Original:", content);
console.log("Formatted:", formatted);

// Get keyboard hints
console.log("\nKeyboard hints:", accessibilityManager.getKeyboardHints());

// Trust building features for agent interfaces
// 智能体界面的信任建设功能
import { ChatOpenAI } from "@langchain/openai";

// Trust indicators
// 信任指标
interface TrustIndicators {
  accuracy: number;
  reliability: number;
  transparency: number;
  competence: number;
  overall: number;
}

// Capability disclosure
// 能力披露
interface CapabilityDisclosure {
  capability: string;
  description: string;
  limitations: string[];
  accuracy?: string;
}

// Trust manager
// 信任管理器
class TrustManager {
  private capabilities: CapabilityDisclosure[] = [];
  private trustHistory: Map<string, TrustIndicators> = new Map();

  // Register agent capabilities
  registerCapabilities(capabilities: CapabilityDisclosure[]): void {
    this.capabilities = capabilities;
    console.log(`[Trust] Registered ${capabilities.length} capabilities`);
  }

  // Get capability disclosure for user
  getCapabilityDisclosure(capability: string): CapabilityDisclosure | undefined {
    return this.capabilities.find(c => c.capability === capability);
  }

  // Generate capability description
  generateCapabilityDescription(): string[] {
    return this.capabilities.map(cap => {
      let description = `**${cap.capability}**: ${cap.description}`;

      if (cap.limitations.length > 0) {
        description += `\n   Limitations: ${cap.limitations.join(", ")}`;
      }

      if (cap.accuracy) {
        description += `\n   Accuracy: ${cap.accuracy}`;
      }

      return description;
    });
  }

  // Update trust score
  updateTrustScore(sessionId: string, indicators: Partial<TrustIndicators>): void {
    const current = this.trustHistory.get(sessionId) || {
      accuracy: 0.8,
      reliability: 0.8,
      transparency: 0.8,
      competence: 0.8,
      overall: 0.8
    };

    const updated = { ...current, ...indicators };
    updated.overall = (
      updated.accuracy +
      updated.reliability +
      updated.transparency +
      updated.competence
    ) / 4;

    this.trustHistory.set(sessionId, updated);
    console.log(`[Trust] Updated trust score for ${sessionId}: ${updated.overall.toFixed(2)}`);
  }

  // Get trust score
  getTrustScore(sessionId: string): TrustIndicators {
    return this.trustHistory.get(sessionId) || {
      accuracy: 0.8,
      reliability: 0.8,
      transparency: 0.8,
      competence: 0.8,
      overall: 0.8
    };
  }

  // Generate trust badge
  generateTrustBadge(): string {
    const avgTrust = 0.85; // Would be calculated from actual data
    let badge = "";

    if (avgTrust >= 0.9) {
      badge = "⭐⭐⭐⭐⭐ Highly Trusted";
    } else if (avgTrust >= 0.8) {
      badge = "⭐⭐⭐⭐ Trusted";
    } else if (avgTrust >= 0.7) {
      badge = "⭐⭐⭐ Generally Reliable";
    } else {
      badge = "⭐⭐ Beta";
    }

    return badge;
  }

  // Generate transparency statement
  generateTransparencyStatement(): string {
    return `This AI assistant:
    - Provides information based on trained data
    - May not always have the most current information
    - Cannot verify real-world accuracy of all claims
    - Should not replace professional advice for important decisions
    - Is continuously learning and improving`;
  }

  // Check if guidance needed
  needsHumanGuidance(confidence: number, taskType: string): boolean {
    // Tasks that always need human oversight
    const criticalTasks = ["medical", "legal", "financial", "health"];
    if (criticalTasks.some(t => taskType.toLowerCase().includes(t))) {
      return true;
    }

    // Low confidence
    return confidence < 0.6;
  }
}

// Example usage: 创建示例
const trustManager = new TrustManager();

// Register capabilities
trustManager.registerCapabilities([
  {
    capability: "Information Retrieval",
    description: "Find and summarize information from various sources",
    limitations: ["May not have latest information", "Cannot browse live websites"],
    accuracy: "~85% for general topics"
  },
  {
    capability: "Data Analysis",
    description: "Analyze data and provide insights",
    limitations: ["Limited to provided data", "Cannot access external databases"]
  },
  {
    capability: "Writing Assistance",
    description: "Help with writing, editing, and proofreading",
    limitations: ["Style preferences may vary"]
  }
]);

// Update trust based on interactions
trustManager.updateTrustScore("session-1", {
  accuracy: 0.9,
  reliability: 0.85
});

console.log("\n=== Trust Features ===");
console.log("Capability disclosures:");
trustManager.generateCapabilityDescription().forEach(c => console.log(c));

console.log("\nTransparency statement:");
console.log(trustManager.generateTransparencyStatement());

console.log("\nTrust badge:", trustManager.generateTrustBadge());
console.log("Needs human guidance:", trustManager.needsHumanGuidance(0.5, "medical advice"));

// Investment agent with excellent UX
// 具有出色用户体验的投资智能体
import { ChatOpenAI } from "@langchain/openai";

// Investment-specific UX components
// 投资特定的用户体验组件
interface TradeExplanation {
  action: string;
  rationale: string;
  riskLevel: string;
  expectedOutcome: string;
  alternatives: string[];
  confidence: number;
}

// Investment UX manager
// 投资用户体验管理器
class InvestmentUXManager {
  private conversationManager: ConversationManager;
  private feedbackCollector: FeedbackCollector;
  private trustManager: TrustManager;
  private explanationBuilder: ExplainableResponseBuilder;

  constructor() {
    this.conversationManager = new ConversationManager();
    this.feedbackCollector = new FeedbackCollector();
    this.trustManager = new TrustManager();
    this.explanationBuilder = new ExplainableResponseBuilder();
  }

  // Handle investment query
  async handleQuery(
    sessionId: string,
    query: string
  ): Promise<{
    response: string;
    explanation?: Explanation;
    tradeInfo?: TradeExplanation;
  }> {
    // Add user message
    this.conversationManager.addMessage(sessionId, "user", query);

    // Set agent state to thinking
    this.conversationManager.setAgentState(sessionId, "thinking");

    // Generate response (simplified)
    const response = "Based on your risk profile and current market conditions, I recommend considering a diversified portfolio with 60% stocks and 40% bonds.";

    // Generate explanation
    const explanation = await this.explanationBuilder.generateExplanation(
      ExplanationType.RECOMMENDATION,
      "Recommended 60/40 portfolio allocation",
      {
        riskProfile: "moderate",
        marketCondition: "bull",
        confidence: 0.78
      }
    );

    // Add agent response
    this.conversationManager.addMessage(sessionId, "agent", response, {
      intent: "portfolio_recommendation",
      confidence: 0.78
    });

    // Set agent state back to idle
    this.conversationManager.setAgentState(sessionId, "idle");

    // Check if human guidance needed
    if (this.trustManager.needsHumanGuidance(0.78, "investment advice")) {
      return {
        response: response + "\n\n⚠️ Please consult with a financial advisor for personalized advice.",
        explanation,
        tradeInfo: {
          action: "Portfolio rebalancing",
          rationale: "Diversification based on risk profile",
          riskLevel: "Moderate",
          expectedOutcome: "Balanced growth with controlled volatility",
          alternatives: ["More aggressive (80/20)", "More conservative (40/60)"],
          confidence: 0.78
        }
      };
    }

    return { response, explanation, tradeInfo: undefined };
  }

  // Collect user feedback
  collectFeedback(sessionId: string, rating: number, comment?: string): void {
    this.feedbackCollector.collectFeedback(sessionId, FeedbackType.SATISFACTION, rating, comment);
  }

  // Get session status
  getSessionStatus(sessionId: string): any {
    const context = this.conversationManager.getContext(sessionId);
    const trustScore = this.trustManager.getTrustScore(sessionId);
    const feedback = this.feedbackCollector.getSessionFeedback(sessionId);

    return {
      hasSession: !!context,
      agentState: context?.agentState || "unknown",
      messageCount: context?.messages.length || 0,
      trustScore,
      feedbackCount: feedback.length
    };
  }
}

// Example: Run investment UX demo
// 示例：运行投资用户体验演示
async function demoInvestmentUX() {
  const uxManager = new InvestmentUXManager();
  const sessionId = "investor-123";

  // Create session
  uxManager.getSessionStatus(sessionId);

  console.log("\n=== Investment Agent UX Demo ===\n");

  // Handle query
  const result = await uxManager.handleQuery(
    sessionId,
    "What's a good investment strategy for me?"
  );

  console.log("Response:", result.response);
  console.log("\nTrade Info:", result.tradeInfo);

  // Collect feedback
  uxManager.collectFeedback(sessionId, 5, "Very helpful explanation!");

  // Get session status
  console.log("\nSession Status:", uxManager.getSessionStatus(sessionId));
}

demoInvestmentUX();