@elizaos/plugin-research 0.1.0

package/src/examples/test-file-logging.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env bun
+/**
+ * Test file logging functionality with a simple research example
+ */
+
+import { ResearchService } from '../service';
+import { IAgentRuntime } from '@elizaos/core';
+import { v4 as uuidv4 } from 'uuid';
+import fs from 'fs/promises';
+import path from 'path';
+
+// Enable file logging
+process.env.FILE_LOGGING = 'true';
+
+// Create a simple runtime
+const runtime = {
+  getSetting: (key: string) => {
+    if (key === 'FILE_LOGGING') return 'true';
+    if (key === 'TAVILY_API_KEY') return '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';
+    return null;
+  },
+  useModel: async () => 'Mock response',
+  logger: {
+    info: console.log,
+    warn: console.warn,
+    error: console.error,
+    debug: () => {},
+  },
+  getService: () => null,
+} as unknown as IAgentRuntime;
+
+async function testFileLogging() {
+  console.log('🧪 Testing File Logging Functionality\n');
+
+  // Create research service
+  const service = new ResearchService(runtime);
+
+  // Create sources first
+  const source1 = {
+    id: uuidv4(),
+    url: 'https://example.com/ai-research',
+    title: 'Latest AI Research 2024',
+    content: 'This is a test source about AI advancements...',
+    accessedAt: Date.now(),
+    type: 'web' as const,
+    reliability: 0.9,
+    metadata: {
+      author: ['Test Author'],
+      publishDate: '2024-01-15',
+      domain: 'example.com',
+      language: 'en',
+    },
+  };
+
+  const source2 = {
+    id: uuidv4(),
+    url: 'https://example.org/machine-learning',
+    title: 'Machine Learning Breakthroughs',
+    content: 'Recent breakthroughs in machine learning include...',
+    accessedAt: Date.now(),
+    type: 'web' as const,
+    reliability: 0.85,
+    metadata: {
+      author: ['ML Expert'],
+      publishDate: '2024-02-20',
+      domain: 'example.org',
+      language: 'en',
+    },
+  };
+
+  // Create a mock research project
+  const projectId = uuidv4();
+  const mockProject = {
+    id: projectId,
+    query: 'Test research about AI advancements',
+    status: 'completed' as const,
+    phase: 'reporting' as const,
+    createdAt: Date.now(),
+    completedAt: Date.now() + 5000,
+    sources: [source1, source2],
+    findings: [
+      {
+        id: uuidv4(),
+        content: 'Large language models have shown significant improvements in reasoning capabilities.',
+        source: source1,
+        relevance: 0.95,
+        confidence: 0.9,
+        category: 'llm',
+        timestamp: Date.now(),
+        citations: [],
+        factualClaims: [
+          {
+            id: uuidv4(),
+            statement: 'LLMs show improved reasoning',
+            supportingEvidence: ['Research shows LLMs can solve complex problems'],
+            sourceUrls: ['https://example.com/ai-research'],
+            verificationStatus: 'verified' as const,
+            confidenceScore: 0.9,
+            relatedClaims: [],
+          },
+        ],
+        relatedFindings: [],
+        verificationStatus: 'verified' as const,
+        extractionMethod: 'manual',
+      },
+      {
+        id: uuidv4(),
+        content: 'Multimodal AI systems can now process text, images, and audio simultaneously.',
+        source: source2,
+        relevance: 0.9,
+        confidence: 0.85,
+        category: 'multimodal',
+        timestamp: Date.now(),
+        citations: [],
+        factualClaims: [
+          {
+            id: uuidv4(),
+            statement: 'Multimodal AI processes multiple data types',
+            supportingEvidence: ['Systems can handle text, images, and audio'],
+            sourceUrls: ['https://example.org/machine-learning'],
+            verificationStatus: 'verified' as const,
+            confidenceScore: 0.85,
+            relatedClaims: [],
+          },
+        ],
+        relatedFindings: [],
+        verificationStatus: 'verified' as const,
+        extractionMethod: 'manual',
+      },
+    ],
+    metadata: {
+      domain: 'computer_science',
+      taskType: 'analytical',
+      depth: 'comprehensive',
+      synthesis: 'The year 2024 has witnessed remarkable advances in artificial intelligence, particularly in large language models and multimodal systems. LLMs have demonstrated enhanced reasoning capabilities, while multimodal systems have achieved unprecedented integration across different data types.',
+      categoryAnalysis: {
+        llm: 'Large language models have evolved to show emergent reasoning abilities, with improvements in mathematical problem-solving and logical deduction.',
+        multimodal: 'Multimodal AI represents a significant leap forward, enabling systems to understand and generate content across multiple modalities seamlessly.',
+      },
+    },
+    report: null,
+  };
+
+  // Store the project
+  (service as any).projects.set(projectId, mockProject);
+
+  // Generate report (this will trigger file saving)
+  console.log('📝 Generating report...');
+  await (service as any).generateReport(mockProject);
+
+  console.log('✅ Report generation complete\n');
+
+  // Check if files were created
+  const logsDir = path.join(process.cwd(), 'research_logs');
+  
+  try {
+    const files = await fs.readdir(logsDir);
+    console.log('📁 Files created in research_logs/:');
+    
+    const mdFiles = files.filter(f => f.endsWith('.md'));
+    const jsonFiles = files.filter(f => f.endsWith('.json'));
+    
+    if (mdFiles.length > 0) {
+      console.log('\nMarkdown files:');
+      mdFiles.forEach(file => console.log(`  📄 ${file}`));
+    }
+    
+    if (jsonFiles.length > 0) {
+      console.log('\nJSON files:');
+      jsonFiles.forEach(file => console.log(`  📊 ${file}`));
+    }
+
+    // Read and display the first markdown file
+    if (mdFiles.length > 0) {
+      console.log('\n📖 Preview of the first report:\n');
+      console.log('─'.repeat(80));
+      
+      const content = await fs.readFile(path.join(logsDir, mdFiles[0]), 'utf-8');
+      // Show first 50 lines
+      const lines = content.split('\n');
+      const preview = lines.slice(0, 50).join('\n');
+      console.log(preview);
+      
+      if (lines.length > 50) {
+        console.log(`\n... (${lines.length - 50} more lines)`);
+      }
+      console.log('─'.repeat(80));
+      
+      console.log(`\n💡 To view the full report, run:`);
+      console.log(`   cat research_logs/${mdFiles[0]}`);
+    }
+    
+  } catch (error) {
+    console.error('❌ Error checking files:', error);
+  }
+}
+
+// Run the test
+testFileLogging().catch(console.error); 

package/src/examples/test-real-research.ts

@@ -0,0 +1,67 @@
+import { IAgentRuntime, elizaLogger } from '@elizaos/core';
+import { ResearchService } from '../service';
+
+export async function testRealResearch(runtime: IAgentRuntime) {
+  elizaLogger.info('🔬 Testing Real Research Functionality');
+  
+  const service = runtime.getService<ResearchService>('research');
+  if (!service) {
+    elizaLogger.error('Research service not available');
+    return;
+  }
+  
+  // Test 1: Simple research query
+  elizaLogger.info('\n📚 Test 1: Simple Research Query');
+  const project1 = await service.createResearchProject(
+    'Latest developments in quantum computing 2024',
+    { maxSearchResults: 3 }
+  );
+  
+  elizaLogger.info(`Created project: ${project1.id}`);
+  elizaLogger.info(`Query: ${project1.query}`);
+  elizaLogger.info(`Status: ${project1.status}`);
+  
+  // Wait a bit and check progress
+  let checkCount = 0;
+  const checkInterval = setInterval(async () => {
+    checkCount++;
+    const current = await service.getProject(project1.id);
+    if (!current) return;
+    
+    elizaLogger.info(`Progress: Phase=${current.phase}, Sources=${current.sources.length}, Findings=${current.findings.length}`);
+    
+    // Sample a finding if available
+    if (current.findings.length > 0 && checkCount === 1) {
+      const sample = current.findings[0];
+      elizaLogger.info(`Sample finding: "${sample.content.substring(0, 200)}..."`);
+      elizaLogger.info(`From source: ${sample.source.title} (${sample.source.url})`);
+    }
+    
+    // Check if completed or timeout
+    if (current.status === 'completed' || current.status === 'failed' || checkCount > 30) {
+      clearInterval(checkInterval);
+      
+      if (current.status === 'completed') {
+        elizaLogger.success(`✅ Research completed successfully!`);
+        elizaLogger.info(`Final results: ${current.sources.length} sources, ${current.findings.length} findings`);
+        
+        if (current.report) {
+          elizaLogger.info(`Report generated with ${current.report.sections.length} sections`);
+        }
+      } else if (current.status === 'failed') {
+        elizaLogger.error(`❌ Research failed: ${current.error}`);
+      } else {
+        elizaLogger.warn(`⏱️  Research timed out after ${checkCount * 5} seconds`);
+      }
+    }
+  }, 5000); // Check every 5 seconds
+}
+
+// Test runner
+export async function runRealResearchTests(runtime: IAgentRuntime) {
+  try {
+    await testRealResearch(runtime);
+  } catch (error) {
+    elizaLogger.error('Test failed:', error);
+  }
+} 

package/src/examples/test-renewable-energy-research.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env bun
+/**
+ * Test script specifically for renewable energy storage research
+ */
+
+// Load environment variables
+import dotenv from 'dotenv';
+import path from 'path';
+dotenv.config({ path: path.join(__dirname, '../../.env') });
+
+import { ResearchService } from '../service';
+import { elizaLogger, IAgentRuntime, ModelType, Character, UUID, asUUID } from '@elizaos/core';
+import { ResearchConfig, ResearchStatus } from '../types';
+import fs from 'fs/promises';
+
+// Create a more complete runtime with real model support
+const createRealRuntime = (): IAgentRuntime => {
+  const testCharacter: Character = {
+    name: 'EnergyResearcher',
+    bio: ['An expert researcher focused on renewable energy and sustainability'],
+    system: 'You are an expert research assistant specializing in renewable energy, environmental science, and grid-scale energy storage technologies.',
+    messageExamples: [],
+    postExamples: [],
+    topics: ['renewable energy', 'energy storage', 'environmental impact', 'grid technology'],
+    adjectives: ['analytical', 'thorough', 'technical'],
+    knowledge: [],
+    plugins: ['research'],
+  };
+
+  return {
+    agentId: asUUID('12345678-1234-1234-1234-123456789012'),
+    character: testCharacter,
+    getSetting: (key: string) => {
+      const value = process.env[key];
+      if (key.includes('API_KEY') && value) {
+        elizaLogger.debug(`[Runtime] Found ${key}`);
+      }
+      return value || null;
+    },
+    getService: (name: string) => null,
+    providers: [],
+    actions: [],
+    evaluators: [],
+    plugins: [],
+    services: new Map(),
+    
+    // Simplified model that returns reasonable responses
+    useModel: async (modelType: string, params: any) => {
+      const messages = params?.messages || [];
+      const lastMessage = messages[messages.length - 1]?.content || '';
+      
+      elizaLogger.debug(`[Model ${modelType}] Processing:`, lastMessage.substring(0, 100) + '...');
+      
+      // Handle different types of model requests
+      if (lastMessage.includes('Analyze this research query')) {
+        return {
+          content: JSON.stringify({
+            domain: 'ENGINEERING',
+            taskType: 'comparative',
+            temporalFocus: 'current',
+            geographicScope: ['global'],
+            requiredExpertise: ['energy storage', 'environmental science', 'economics'],
+            expectedSourceTypes: ['academic', 'technical', 'government']
+          })
+        };
+      } else if (lastMessage.includes('Generate sub-queries')) {
+        return {
+          content: `PURPOSE: Compare different storage technologies
+QUERY: lithium-ion batteries environmental impact grid scale
+TYPE: comparative
+PRIORITY: high
+---
+PURPOSE: Economic analysis of storage technologies
+QUERY: grid scale energy storage cost comparison economics
+TYPE: statistical
+PRIORITY: high
+---
+PURPOSE: Environmental lifecycle assessment
+QUERY: renewable energy storage lifecycle assessment environmental impact
+TYPE: analytical
+PRIORITY: medium`
+        };
+      } else if (lastMessage.includes('Extract key findings')) {
+        return {
+          content: JSON.stringify([{
+            content: "Based on the analysis, lithium-ion batteries currently dominate grid-scale storage with 90% market share, but face environmental challenges in mining and disposal.",
+            relevance: 0.95,
+            confidence: 0.9,
+            category: "fact"
+          }])
+        };
+      } else if (lastMessage.includes('research findings')) {
+        return {
+          content: "The research reveals that while lithium-ion batteries currently dominate grid-scale energy storage, alternative technologies like flow batteries and compressed air storage show promise for specific applications with potentially lower environmental impacts."
+        };
+      }
+      
+      // Default response
+      return { content: "Analysis complete. Findings integrated into research report." };
+    },
+    
+    // Memory managers
+    messageManager: {
+      createMemory: async () => asUUID('12345678-1234-1234-1234-123456789013'),
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    descriptionManager: {
+      createMemory: async () => asUUID('12345678-1234-1234-1234-123456789014'),
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    documentsManager: {
+      createMemory: async () => asUUID('12345678-1234-1234-1234-123456789015'),
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    knowledgeManager: {
+      createMemory: async () => asUUID('12345678-1234-1234-1234-123456789016'),
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    loreManager: {
+      createMemory: async () => asUUID('12345678-1234-1234-1234-123456789017'),
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    
+    stop: async () => {},
+  } as any as IAgentRuntime;
+};
+
+async function testRenewableEnergyResearch() {
+  elizaLogger.info('=== Testing Renewable Energy Storage Research ===');
+  
+  const runtime = createRealRuntime();
+  const service = new ResearchService(runtime);
+  
+  const query = "Compare the environmental and economic impacts of different renewable energy storage technologies for grid-scale deployment";
+  
+  elizaLogger.info(`Research Query: "${query}"`);
+  
+  try {
+    // Create research project with specific configuration
+    const config: Partial<ResearchConfig> = {
+      searchProviders: ['web', 'academic'],
+      maxSearchResults: 10,
+      maxDepth: 3,
+      enableImages: false,
+      evaluationEnabled: false,
+    };
+    
+    const project = await service.createResearchProject(query, config);
+    
+    elizaLogger.info('✅ Project created successfully:', {
+      id: project.id,
+      status: project.status,
+    });
+    
+    // Wait for research to complete (max 30 seconds)
+    let attempts = 0;
+    while (attempts < 30) {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      
+      const currentProject = await service.getProject(project.id);
+      if (!currentProject) break;
+      
+      elizaLogger.info(`Progress: ${currentProject.phase} - Sources: ${currentProject.sources.length}, Findings: ${currentProject.findings.length}`);
+      
+      if (currentProject.status === ResearchStatus.COMPLETED || 
+          currentProject.status === ResearchStatus.FAILED) {
+        elizaLogger.info(`Research ${currentProject.status}`);
+        
+        // Save the report if completed
+        if (currentProject.report) {
+          // Export as markdown
+          const markdownReport = await service.exportProject(project.id, 'markdown');
+          const reportPath = path.join(__dirname, '../../test-renewable-energy-report.md');
+          await fs.writeFile(reportPath, markdownReport);
+          elizaLogger.info(`✅ Report saved to: ${reportPath}`);
+          
+          // Show first 500 chars of the report
+          elizaLogger.info('\n📄 Report Preview:\n' + markdownReport.substring(0, 500) + '...\n');
+          
+          // Check if report contains renewable energy content
+          const hasRelevantContent = markdownReport.toLowerCase().includes('energy') ||
+                                    markdownReport.toLowerCase().includes('storage') ||
+                                    markdownReport.toLowerCase().includes('battery');
+          
+          if (hasRelevantContent) {
+            elizaLogger.info('✅ Report contains relevant renewable energy content!');
+          } else {
+            elizaLogger.error('❌ Report does NOT contain relevant renewable energy content!');
+          }
+        }
+        
+        break;
+      }
+      
+      attempts++;
+    }
+    
+    // Export the project data for analysis
+    const exportData = await service.exportProject(project.id, 'json');
+    const exportPath = path.join(__dirname, '../../test-renewable-energy-export.json');
+    await fs.writeFile(exportPath, exportData);
+    elizaLogger.info(`✅ Project data exported to: ${exportPath}`);
+    
+    await service.stop();
+    
+  } catch (error) {
+    elizaLogger.error('❌ Test failed:', error);
+  }
+  
+  elizaLogger.info('=== Test Complete ===');
+}
+
+// Run the test
+testRenewableEnergyResearch().catch(console.error); 

package/src/index.ts

@@ -0,0 +1,28 @@
+import { Plugin } from '@elizaos/core';
+import { ResearchService } from './service';
+import { researchProviders } from './providers';
+import { researchActions } from './actions';
+import deepResearchBenchSimplifiedTests from './__tests__/deepresearch-bench-simplified.e2e.test';
+
+export * from './types';
+export * from './service';
+export * from './actions';
+export * from './providers';
+export * from './integrations';
+export * from './strategies/research-strategies';
+export * from './evaluation/research-evaluator';
+
+export const researchPlugin: Plugin = {
+  name: 'research',
+  description: 'PhD-level deep research across 22 domains with RACE/FACT evaluation',
+  
+  services: [ResearchService],
+  actions: researchActions,
+  providers: researchProviders,
+  
+  tests: [
+    deepResearchBenchSimplifiedTests
+  ],
+};
+
+export default researchPlugin;

package/src/integrations/cache.ts

@@ -0,0 +1,128 @@
+import { SearchResult } from '../types';
+import { elizaLogger } from '@elizaos/core';
+import { SearchProvider } from './rate-limiter';
+import crypto from 'crypto';
+
+export interface CacheConfig {
+  ttlMinutes?: number;
+  maxSize?: number;
+  sizeCalculation?: (value: SearchResult[], key: string) => number;
+}
+
+// Built-in LRU cache implementation
+class SimpleLRUCache<K, V> {
+  private cache: Map<K, { value: V; timestamp: number }> = new Map();
+  private maxSize: number;
+  private ttl: number;
+
+  constructor(options: { max: number; ttl: number }) {
+    this.maxSize = options.max;
+    this.ttl = options.ttl;
+  }
+
+  get(key: K): V | undefined {
+    const item = this.cache.get(key);
+    if (!item) return undefined;
+    
+    // Check if expired
+    if (Date.now() - item.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return undefined;
+    }
+    
+    // Move to end (LRU behavior)
+    this.cache.delete(key);
+    this.cache.set(key, item);
+    
+    return item.value;
+  }
+
+  set(key: K, value: V): void {
+    // Remove item if it exists (to reinsert at end)
+    this.cache.delete(key);
+    
+    // Remove oldest items if at capacity
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    
+    this.cache.set(key, { value, timestamp: Date.now() });
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+}
+
+export class CachedSearchProvider implements SearchProvider {
+  private cache: SimpleLRUCache<string, SearchResult[]>;
+  public readonly name: string;
+
+  constructor(
+    private provider: SearchProvider,
+    config: CacheConfig = {}
+  ) {
+    this.name = `Cached(${provider.name || 'Unknown'})`;
+    
+    this.cache = new SimpleLRUCache<string, SearchResult[]>({
+      max: config.maxSize || 1000,
+      ttl: (config.ttlMinutes || 60) * 60 * 1000, // Convert to milliseconds
+    });
+  }
+
+  private getCacheKey(query: string, maxResults?: number): string {
+    const keyData = `${query}:${maxResults || 'default'}`;
+    return crypto.createHash('md5').update(keyData).digest('hex');
+  }
+
+  async search(query: string, maxResults?: number): Promise<SearchResult[]> {
+    const cacheKey = this.getCacheKey(query, maxResults);
+    
+    // Check cache first
+    const cached = this.cache.get(cacheKey);
+    if (cached) {
+      elizaLogger.info(`[Cache] Hit for query: ${query}`);
+      return cached;
+    }
+    
+    elizaLogger.info(`[Cache] Miss for query: ${query}`);
+    
+    // Fetch from underlying provider
+    const results = await this.provider.search(query, maxResults);
+    
+    // Store in cache
+    if (results && results.length > 0) {
+      this.cache.set(cacheKey, results);
+    }
+    
+    return results;
+  }
+  
+  // Cache management methods
+  clear(): void {
+    this.cache.clear();
+  }
+  
+  getCacheStats(): { size: number; hits: number; misses: number } {
+    return {
+      size: this.cache.size,
+      hits: 0, // Could track this if needed
+      misses: 0,
+    };
+  }
+}
+
+// Helper to create a cached provider with default settings
+export function withCache(
+  provider: SearchProvider,
+  ttlMinutes: number = 60
+): CachedSearchProvider {
+  return new CachedSearchProvider(provider, { ttlMinutes });
+}