// Capability discovery system for agents
// 智能体的能力发现系统
import { ChatOpenAI } from "@langchain/openai";

// Capability definition
// 能力定义
interface Capability {
  id: string;
  name: string;
  description: string;
  category: string;
  parameters: string[];
  returns: string;
  confidence: number;
  lastVerified: number;
  usageCount: number;
}

// Discovered tool
// 发现的工具
interface DiscoveredTool {
  id: string;
  name: string;
  endpoint: string;
  methods: string[];
  description: string;
  reliability: number;
}

// Capability discovery agent
// 能力发现智能体
class CapabilityDiscoveryAgent {
  private capabilities: Map<string, Capability> = new Map();
  private tools: Map<string, DiscoveredTool> = new Map();
  private discoveryHistory: any[] = [];

  // Discover capabilities from environment
  async discoverCapabilities(environment: any): Promise<Capability[]> {
    const discovered: Capability[] = [];

    // Explore available APIs
    if (environment.apis) {
      for (const api of environment.apis) {
        const capability = await this.exploreAPI(api);
        if (capability) {
          discovered.push(capability);
          this.capabilities.set(capability.id, capability);
        }
      }
    }

    // Explore available tools
    if (environment.tools) {
      for (const tool of environment.tools) {
        const discoveredTool = await this.exploreTool(tool);
        this.tools.set(discoveredTool.id, discoveredTool);
      }
    }

    // Log discovery
    this.discoveryHistory.push({
      timestamp: Date.now(),
      discovered: discovered.length,
      environment: environment.name
    });

    console.log(`[Discovery] Discovered ${discovered.length} new capabilities`);
    return discovered;
  }

  // Explore a single API
  private async exploreAPI(api: any): Promise<Capability | null> {
    // Simulate API exploration
    const capability: Capability = {
      id: `cap-${api.name}`,
      name: api.name,
      description: api.description || `API for ${api.name}`,
      category: api.category || "general",
      parameters: api.parameters || [],
      returns: api.returns || "unknown",
      confidence: 0.9,
      lastVerified: Date.now(),
      usageCount: 0
    };

    return capability;
  }

  // Explore a tool
  private async exploreTool(tool: any): Promise<DiscoveredTool> {
    return {
      id: `tool-${tool.name}`,
      name: tool.name,
      endpoint: tool.endpoint,
      methods: tool.methods || ["execute"],
      description: tool.description,
      reliability: 0.85
    };
  }

  // Get capability by category
  getCapabilitiesByCategory(category: string): Capability[] {
    return Array.from(this.capabilities.values())
      .filter(c => c.category === category);
  }

  // Find capability for task
  findCapabilityForTask(task: string): Capability | null {
    const allCaps = Array.from(this.capabilities.values());

    // Simple keyword matching
    for (const cap of allCaps) {
      if (task.toLowerCase().includes(cap.name.toLowerCase()) ||
          cap.description.toLowerCase().includes(task.toLowerCase())) {
        return cap;
      }
    }

    return null;
  }

  // Update capability usage
  recordCapabilityUsage(capabilityId: string): void {
    const capability = this.capabilities.get(capabilityId);
    if (capability) {
      capability.usageCount++;
      capability.lastVerified = Date.now();
    }
  }

  // Get discovery report
  getDiscoveryReport(): any {
    const caps = Array.from(this.capabilities.values());
    const categories = new Set(caps.map(c => c.category));

    return {
      totalCapabilities: caps.length,
      byCategory: Object.fromEntries(
        Array.from(categories).map(cat => [
          cat,
          caps.filter(c => c.category === cat).length
        ])
      ),
      mostUsed: caps.sort((a, b) => b.usageCount - a.usageCount).slice(0, 5),
      discoveryHistory: this.discoveryHistory
    };
  }
}

// Example usage: 创建示例
const discoveryAgent = new CapabilityDiscoveryAgent();

// Discover capabilities from environment
const env = {
  name: "trading-platform",
  apis: [
    { name: "get_stock_price", description: "Get current stock price", category: "market_data" },
    { name: "place_order", description: "Place trading order", category: "trading" },
    { name: "get_portfolio", description: "Get portfolio holdings", category: "portfolio" }
  ],
  tools: [
    { name: "calculator", endpoint: "/tools/calc", methods: ["compute"] },
    { name: "notifier", endpoint: "/tools/notify", methods: ["send", "schedule"] }
  ]
};

discoveryAgent.discoverCapabilities(env);

console.log("\n=== Discovery Report ===");
console.log(discoveryAgent.getDiscoveryReport());

// Information gathering and exploration system
// 信息收集和探索系统
import { ChatOpenAI } from "@langchain/openai";

// Information source
// 信息源
interface InformationSource {
  id: string;
  type: "api" | "database" | "web" | "file";
  name: string;
  endpoint?: string;
  reliability: number;
  lastUpdated: number;
  schema?: any;
}

// Gathered information
// 收集的信息
interface GatheredInformation {
  source: string;
  data: any;
  timestamp: number;
  relevance: number;
  freshness: number;
}

// Information gathering agent
// 信息收集智能体
class InformationGatheringAgent {
  private sources: Map<string, InformationSource> = new Map();
  private gatheredInfo: GatheredInformation[] = [];
  private explorationBudget = 100; // Max API calls per session

  // Register information source
  registerSource(source: InformationSource): void {
    this.sources.set(source.id, source);
    console.log(`[Info] Registered source: ${source.name}`);
  }

  // Gather information about topic
  async gatherInformation(topic: string, maxSources: number = 5): Promise<GatheredInformation[]> {
    const results: GatheredInformation[] = [];

    // Find relevant sources
    const relevantSources = Array.from(this.sources.values())
      .filter(s => this.isRelevant(s, topic))
      .slice(0, maxSources);

    for (const source of relevantSources) {
      if (this.explorationBudget <= 0) break;

      try {
        const info = await this.querySource(source, topic);
        results.push(info);
        this.gatheredInfo.push(info);
        this.explorationBudget--;

        console.log(`[Info] Gathered from ${source.name}: ${info.relevance}% relevant`);
      } catch (error) {
        console.error(`[Info] Failed to query ${source.name}:`, error);
      }
    }

    return results;
  }

  // Check if source is relevant to topic
  private isRelevant(source: InformationSource, topic: string): boolean {
    // Simple relevance check
    return source.name.toLowerCase().includes(topic.toLowerCase().split(" ")[0]) ||
           source.type === "web";
  }

  // Query a source
  private async querySource(source: InformationSource, topic: string): Promise<GatheredInformation> {
    // Simulate querying
    await new Promise(resolve => setTimeout(resolve, 100));

    return {
      source: source.name,
      data: { topic, results: [`Result from ${source.name}`] },
      timestamp: Date.now(),
      relevance: Math.random() * 0.5 + 0.5, // 50-100%
      freshness: Math.random() * 0.3 + 0.7 // 70-100%
    };
  }

  // Explore related topics
  async exploreRelatedTopics(topic: string): Promise<string[]> {
    // Use LLM to suggest related topics
    const related = [
      `${topic} trends`,
      `${topic} analysis`,
      `${topic} news`,
      `${topic} forecast`
    ];

    return related;
  }

  // Get information synthesis
  synthesizeInformation(topic: string): any {
    const relevant = this.gatheredInfo.filter(info =>
      info.data.topic === topic
    );

    if (relevant.length === 0) {
      return { status: "no_data", message: "No information gathered for this topic" };
    }

    // Calculate aggregate metrics
    const avgRelevance = relevant.reduce((sum, i) => sum + i.relevance, 0) / relevant.length;
    const avgFreshness = relevant.reduce((sum, i) => sum + i.freshness, 0) / relevant.length;

    return {
      topic,
      sourceCount: relevant.length,
      avgRelevance,
      avgFreshness,
      sources: relevant.map(i => i.source),
      synthesized: "Information synthesized from multiple sources"
    };
  }

  // Get exploration budget
  getBudget(): number {
    return this.explorationBudget;
  }
}

// Example usage: 创建示例
const gatheringAgent = new InformationGatheringAgent();

// Register sources
gatheringAgent.registerSource({
  id: "yahoo-finance",
  type: "api",
  name: "Yahoo Finance",
  endpoint: "https://query1.finance.yahoo.com",
  reliability: 0.9,
  lastUpdated: Date.now()
});

gatheringAgent.registerSource({
  id: "market-watch",
  type: "web",
  name: "MarketWatch",
  reliability: 0.85,
  lastUpdated: Date.now()
});

gatheringAgent.registerSource({
  id: "sec-api",
  type: "api",
  name: "SEC API",
  reliability: 0.95,
  lastUpdated: Date.now()
});

// Gather information
gatheringAgent.gatherInformation("AAPL stock").then(info => {
  console.log("\nGathered information:", info);
});

// Synthesize
console.log("\nSynthesis:", gatheringAgent.synthesizeInformation("AAPL stock"));
console.log("Budget remaining:", gatheringAgent.getBudget());

// Experimentation framework for agent improvement
// 智能体改进的实验框架
import { ChatOpenAI } from "@langchain/openai";

// Experiment definition
// 实验定义
interface Experiment {
  id: string;
  name: string;
  description: string;
  hypothesis: string;
  status: "draft" | "running" | "completed" | "paused";
  variant: string;
  control: string;
  startDate?: number;
  endDate?: number;
  metrics: ExperimentMetric[];
  results?: ExperimentResults;
}

// Experiment metric
// 实验指标
interface ExperimentMetric {
  name: string;
  value: number;
  target?: number;
}

// Experiment results
// 实验结果
interface ExperimentResults {
  control: Record<string, number>;
  variant: Record<string, number>;
  winner: "control" | "variant" | "inconclusive";
  confidence: number;
  pValue?: number;
}

// Experiment runner
// 实验运行器
class ExperimentationFramework {
  private experiments: Map<string, Experiment> = new Map();
  private activeExperiments: Set<string> = new Set();

  // Create experiment
  createExperiment(
    name: string,
    description: string,
    hypothesis: string
  ): Experiment {
    const experiment: Experiment = {
      id: `exp-${Date.now()}`,
      name,
      description,
      hypothesis,
      status: "draft",
      variant: "new_approach",
      control: "baseline",
      metrics: []
    };

    this.experiments.set(experiment.id, experiment);
    console.log(`[Experiment] Created: ${experiment.id}`);

    return experiment;
  }

  // Start experiment
  startExperiment(experimentId: string): void {
    const exp = this.experiments.get(experimentId);
    if (!exp) throw new Error("Experiment not found");

    exp.status = "running";
    exp.startDate = Date.now();
    this.activeExperiments.add(experimentId);

    console.log(`[Experiment] Started: ${experimentId}`);
  }

  // Record metric
  recordMetric(experimentId: string, metricName: string, value: number): void {
    const exp = this.experiments.get(experimentId);
    if (!exp) return;

    exp.metrics.push({
      name: metricName,
      value
    });
  }

  // Run A/B test
  runABTest(
    experimentId: string,
    controlData: Record<string, number>,
    variantData: Record<string, number>
  ): ExperimentResults {
    // Calculate winner (simplified)
    const controlAvg = Object.values(controlData).reduce((a, b) => a + b, 0) / Object.values(controlData).length;
    const variantAvg = Object.values(variantData).reduce((a, b) => a + b, 0) / Object.values(variantData).length;

    const improvement = ((variantAvg - controlAvg) / controlAvg) * 100;
    const confidence = Math.min(0.99, Math.abs(improvement) / 10);

    let winner: "control" | "variant" | "inconclusive" = "inconclusive";
    if (confidence > 0.95 && improvement > 5) {
      winner = "variant";
    } else if (confidence > 0.95 && improvement < -5) {
      winner = "control";
    }

    const results: ExperimentResults = {
      control: controlData,
      variant: variantData,
      winner,
      confidence
    };

    // Update experiment
    const exp = this.experiments.get(experimentId);
    if (exp) {
      exp.results = results;
      exp.status = "completed";
      exp.endDate = Date.now();
      this.activeExperiments.delete(experimentId);
    }

    return results;
  }

  // Get active experiments
  getActiveExperiments(): Experiment[] {
    return Array.from(this.experiments.values())
      .filter(exp => exp.status === "running");
  }

  // Get experiment by ID
  getExperiment(experimentId: string): Experiment | undefined {
    return this.experiments.get(experimentId);
  }

  // Get all experiments
  getAllExperiments(): Experiment[] {
    return Array.from(this.experiments.values());
  }
}

// Example usage: 创建示例
const framework = new ExperimentationFramework();

// Create experiment
const exp = framework.createExperiment(
  "Response Formatting Test",
  "Testing different response formats",
  "Users prefer shorter, bulleted responses"
);

// Start experiment
framework.startExperiment(exp.id);

// Simulate data collection
for (let i = 0; i < 100; i++) {
  framework.recordMetric(exp.id, "engagement", Math.random());
}

// Run A/B test
const results = framework.runABTest(
  exp.id,
  { engagement: 0.65, completion: 0.70 },
  { engagement: 0.75, completion: 0.80 }
);

console.log("\n=== Experiment Results ===");
console.log("Winner:", results.winner);
console.log("Confidence:", (results.confidence * 100).toFixed(1) + "%");

// Feedback-driven learning system
// 反馈驱动学习系统
import { ChatOpenAI } from "@langchain/openai";

// Feedback item
// 反馈项
interface FeedbackItem {
  id: string;
  type: "explicit" | "implicit" | "behavioral";
  context: string;
  rating?: number;
  action?: string;
  outcome?: string;
  timestamp: number;
}

// Learning insight
// 学习洞察
interface LearningInsight {
  id: string;
  description: string;
  source: string;
  confidence: number;
  action: string;
  implemented: boolean;
}

// Feedback-driven learning agent
// 反馈驱动学习智能体
class FeedbackDrivenLearningAgent {
  private feedbackHistory: FeedbackItem[] = [];
  private insights: LearningInsight[] = [];
  private behaviorModel: Map<string, number> = new Map();

  // Record explicit feedback
  recordFeedback(
    type: "explicit" | "implicit" | "behavioral",
    context: string,
    rating?: number,
    action?: string
  ): void {
    const feedback: FeedbackItem = {
      id: `fb-${Date.now()}`,
      type,
      context,
      rating,
      action,
      timestamp: Date.now()
    };

    this.feedbackHistory.push(feedback);
    console.log(`[Learning] Recorded ${type} feedback: ${context}`);

    // Trigger learning if enough feedback
    if (this.feedbackHistory.length % 10 === 0) {
      this.learn();
    }
  }

  // Record behavioral feedback
  recordBehavior(action: string, outcome: string): void {
    this.recordFeedback("behavioral", action, undefined, outcome);

    // Update behavior model
    const currentCount = this.behaviorModel.get(action) || 0;
    this.behaviorModel.set(action, currentCount + 1);
  }

  // Learning process
  private learn(): void {
    console.log("\n[Learning] Processing feedback...");

    // Analyze feedback patterns
    const patterns = this.analyzePatterns();

    // Generate insights
    for (const pattern of patterns) {
      const insight = this.generateInsight(pattern);
      if (insight) {
        this.insights.push(insight);
        console.log(`[Learning] New insight: ${insight.description}`);
      }
    }
  }

  // Analyze feedback patterns
  private analyzePatterns(): any[] {
    const patterns: any[] = [];

    // Group by context
    const byContext = new Map<string, FeedbackItem[]>();
    for (const fb of this.feedbackHistory) {
      const existing = byContext.get(fb.context) || [];
      existing.push(fb);
      byContext.set(fb.context, existing);
    }

    // Find patterns
    for (const [context, items] of byContext) {
      if (items.length >= 5) {
        const ratings = items.filter(i => i.rating !== undefined).map(i => i.rating!);
        const avgRating = ratings.length > 0
          ? ratings.reduce((a, b) => a + b, 0) / ratings.length
          : null;

        patterns.push({
          context,
          count: items.length,
          avgRating,
          type: items[0].type
        });
      }
    }

    return patterns;
  }

  // Generate insight from pattern
  private generateInsight(pattern: any): LearningInsight | null {
    // Simple insight generation
    if (pattern.avgRating !== null && pattern.avgRating < 3) {
      return {
        id: `insight-${Date.now()}`,
        description: `Low rating for ${pattern.context} (${pattern.avgRating.toFixed(1)})`,
        source: "feedback_analysis",
        confidence: 0.8,
        action: `improve_${pattern.context}`,
        implemented: false
      };
    }

    return null;
  }

  // Get actionable insights
  getActionableInsights(): LearningInsight[] {
    return this.insights.filter(i => !i.implemented && i.confidence > 0.7);
  }

  // Implement insight
  implementInsight(insightId: string): void {
    const insight = this.insights.find(i => i.id === insightId);
    if (insight) {
      insight.implemented = true;
      console.log(`[Learning] Implemented: ${insight.description}`);
    }
  }

  // Get behavior recommendations
  getBehaviorRecommendations(context: string): string[] {
    const recommendations: string[] = [];

    // Based on behavior model
    for (const [action, count] of this.behaviorModel) {
      if (count > 10) {
        recommendations.push(`Continue: ${action} (${count} times)`);
      }
    }

    return recommendations;
  }
}

// Example usage: 创建示例
const learningAgent = new FeedbackDrivenLearningAgent();

// Record feedback
learningAgent.recordFeedback("explicit", "response_clarity", 4);
learningAgent.recordFeedback("explicit", "response_clarity", 3);
learningAgent.recordFeedback("explicit", "response_clarity", 5);
learningAgent.recordFeedback("explicit", "response_speed", 5);
learningAgent.recordFeedback("implicit", "user_retention", 4);

// Record behaviors
learningAgent.recordBehavior("provide_summary", "positive");
learningAgent.recordBehavior("provide_detail", "neutral");
learningAgent.recordBehavior("provide_summary", "positive");

// Get insights
console.log("\n=== Actionable Insights ===");
console.log(learningAgent.getActionableInsights());

console.log("\n=== Behavior Recommendations ===");
console.log(learningAgent.getBehaviorRecommendations("general"));

// Anomaly detection for exploration
// 探索的异常检测
import { ChatOpenAI } from "@langchain/openai";

// Data point
// 数据点
interface DataPoint {
  id: string;
  timestamp: number;
  value: number;
  features: Record<string, number>;
  isAnomaly: boolean;
  anomalyScore?: number;
}

// Anomaly detection agent
// 异常检测智能体
class AnomalyDetectionAgent {
  private dataWindow: DataPoint[] = [];
  private maxWindowSize = 1000;
  private anomalies: DataPoint[] = [];

  // Add data point
  addDataPoint(value: number, features: Record<string, number>): DataPoint {
    const point: DataPoint = {
      id: `dp-${Date.now()}`,
      timestamp: Date.now(),
      value,
      features,
      isAnomaly: false
    };

    // Detect anomaly
    const { isAnomaly, score } = this.detectAnomaly(point);
    point.isAnomaly = isAnomaly;
    point.anomalyScore = score;

    // Store
    this.dataWindow.push(point);
    if (this.dataWindow.length > this.maxWindowSize) {
      this.dataWindow.shift();
    }

    if (isAnomaly) {
      this.anomalies.push(point);
      console.log(`[Anomaly] Detected anomaly: ${score.toFixed(2)} - ${JSON.stringify(features)}`);
    }

    return point;
  }

  // Detect anomaly using statistical methods
  private detectAnomaly(point: DataPoint): { isAnomaly: boolean; score: number } {
    if (this.dataWindow.length < 10) {
      return { isAnomaly: false, score: 0 };
    }

    // Calculate statistics
    const values = this.dataWindow.slice(-50).map(d => d.value);
    const mean = values.reduce((a, b) => a + b, 0) / values.length;
    const std = Math.sqrt(
      values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length
    );

    // Z-score
    const zScore = Math.abs((point.value - mean) / (std || 1));
    const isAnomaly = zScore > 2.5; // Threshold

    return { isAnomaly, score: zScore };
  }

  // Detect pattern changes
  detectPatternChange(windowSize: number = 20): boolean {
    if (this.dataWindow.length < windowSize * 2) return false;

    const recent = this.dataWindow.slice(-windowSize);
    const previous = this.dataWindow.slice(-windowSize * 2, -windowSize);

    const recentMean = recent.reduce((s, d) => s + d.value, 0) / recent.length;
    const prevMean = previous.reduce((s, d) => s + d.value, 0) / previous.length;

    const change = Math.abs((recentMean - prevMean) / prevMean);
    return change > 0.2; // 20% change
  }

  // Get anomaly report
  getAnomalyReport(): any {
    const recentAnomalies = this.anomalies.filter(
      a => Date.now() - a.timestamp < 24 * 60 * 60 * 1000
    );

    return {
      totalAnomalies: this.anomalies.length,
      recentAnomalies: recentAnomalies.length,
      avgAnomalyScore: recentAnomalies.length > 0
        ? recentAnomalies.reduce((s, a) => s + (a.anomalyScore || 0), 0) / recentAnomalies.length
        : 0,
      hasPatternChange: this.detectPatternChange(),
      recentAnomalyDetails: recentAnomalies.slice(-5).map(a => ({
        timestamp: new Date(a.timestamp).toISOString(),
        value: a.value,
        score: a.anomalyScore?.toFixed(2)
      }))
    };
  }
}

// Example usage: 创建示例
const anomalyDetector = new AnomalyDetectionAgent();

// Simulate data stream
for (let i = 0; i < 100; i++) {
  const value = 100 + Math.random() * 20;
  anomalyDetector.addDataPoint(value, { source: "market_data", symbol: "AAPL" });
}

// Add some anomalies
anomalyDetector.addDataPoint(180, { source: "market_data", symbol: "AAPL" });
anomalyDetector.addDataPoint(50, { source: "market_data", symbol: "AAPL" });

console.log("\n=== Anomaly Report ===");
console.log(anomalyDetector.getAnomalyReport());

// Investment agent with exploration and discovery capabilities
// 具有探索和发现能力的投资智能体
import { ChatOpenAI } from "@langchain/openai";

// Market opportunity
// 市场机会
interface MarketOpportunity {
  id: string;
  type: "trend" | "anomaly" | "pattern" | "discovery";
  description: string;
  confidence: number;
  potential: number;
  risk: number;
  discoveredAt: number;
  actions: string[];
}

// Investment exploration agent
// 投资探索智能体
class InvestmentExplorationAgent {
  private discoveryAgent: CapabilityDiscoveryAgent;
  private infoGatheringAgent: InformationGatheringAgent;
  private anomalyDetector: AnomalyDetectionAgent;
  private experimentationFramework: ExperimentationFramework;
  private learningAgent: FeedbackDrivenLearningAgent;
  private opportunities: MarketOpportunity[] = [];

  constructor() {
    this.discoveryAgent = new CapabilityDiscoveryAgent();
    this.infoGatheringAgent = new InformationGatheringAgent();
    this.anomalyDetector = new AnomalyDetectionAgent();
    this.experimentationFramework = new ExperimentationFramework();
    this.learningAgent = new FeedbackDrivenLearningAgent();
  }

  // Explore market for opportunities
  async exploreMarket(symbols: string[]): Promise<MarketOpportunity[]> {
    const opportunities: MarketOpportunity[] = [];

    // 1. Gather market information
    for (const symbol of symbols) {
      await this.infoGatheringAgent.gatherInformation(`${symbol} stock`, 3);
    }

    // 2. Detect anomalies in price data
    for (const symbol of symbols) {
      // Simulate price data
      for (let i = 0; i < 50; i++) {
        const price = 100 + Math.random() * 30;
        this.anomalyDetector.addDataPoint(price, { symbol, type: "price" });
      }
    }

    // 3. Analyze for opportunities
    const anomalyReport = this.anomalyDetector.getAnomalyReport();
    if (anomalyReport.hasPatternChange) {
      opportunities.push({
        id: `opp-${Date.now()}`,
        type: "pattern",
        description: "Significant pattern change detected",
        confidence: 0.75,
        potential: 0.8,
        risk: 0.6,
        discoveredAt: Date.now(),
        actions: ["investigate_pattern", "adjust_strategy"]
      });
    }

    // 4. Record learning from exploration
    this.learningAgent.recordFeedback(
      "behavioral",
      "market_exploration",
      undefined,
      opportunities.length > 0 ? "positive" : "neutral"
    );

    this.opportunities = opportunities;
    return opportunities;
  }

  // Discover new investment strategies
  async discoverStrategies(): Promise<string[]> {
    // Use experimentation to discover better strategies
    const exp = this.experimentationFramework.createExperiment(
      "Strategy Discovery",
      "Testing new investment strategies",
      "New strategies will outperform baseline"
    );

    this.experimentationFramework.startExperiment(exp.id);

    // Simulate testing
    const strategies = [
      "momentum_strategy",
      "mean_reversion",
      "pairs_trading",
      "sector_rotation"
    ];

    return strategies;
  }

  // Get market insights
  getMarketInsights(): any {
    return {
      opportunities: this.opportunities.length,
      anomalyReport: this.anomalyDetector.getAnomalyReport(),
      actionableInsights: this.learningAgent.getActionableInsights(),
      explorationBudget: this.infoGatheringAgent.getBudget()
    };
  }
}

// Example: Run investment exploration
// 示例：运行投资探索
async function demoInvestmentExploration() {
  const explorationAgent = new InvestmentExplorationAgent();

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

  // Explore market
  const opportunities = await explorationAgent.exploreMarket(["AAPL", "GOOGL", "MSFT"]);

  console.log("\nDiscovered opportunities:");
  opportunities.forEach(opp => {
    console.log(`  - ${opp.type}: ${opp.description} (confidence: ${opp.confidence})`);
  });

  // Discover strategies
  const strategies = await explorationAgent.discoverStrategies();
  console.log("\nPotential strategies:", strategies);

  // Get insights
  console.log("\nMarket insights:", explorationAgent.getMarketInsights());
}

demoInvestmentExploration();