@elizaos/plugin-research 0.1.0

package/src/examples/debug-research-query.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+/**
+ * Debug script to test research query handling
+ */
+
+import { ResearchService } from '../service';
+import { elizaLogger, IAgentRuntime } from '@elizaos/core';
+import { ResearchConfig, ResearchStatus } from '../types';
+import { Character } from '@elizaos/core';
+
+// Create a minimal runtime for testing
+const createTestRuntime = (): IAgentRuntime => {
+  const testCharacter: Character = {
+    name: 'TestResearcher',
+    bio: ['A test researcher for debugging'],
+    system: 'You are a research assistant focused on technical topics.',
+    messageExamples: [],
+    postExamples: [],
+    topics: ['technology', 'science', 'research'],
+    adjectives: ['analytical', 'thorough'],
+    knowledge: [],
+    plugins: ['research'],
+  };
+
+  return {
+    agentId: 'test-agent-id',
+    character: testCharacter,
+    getSetting: (key: string) => {
+      // Return actual environment variables
+      const value = process.env[key];
+      elizaLogger.debug(`[Runtime] getSetting(${key}) = ${value ? '<REDACTED>' : 'null'}`);
+      return value || null;
+    },
+    getService: (name: string) => {
+      return null;
+    },
+    providers: [],
+    actions: [],
+    evaluators: [],
+    plugins: [],
+    services: new Map(),
+    messageManager: {
+      createMemory: async () => true,
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    descriptionManager: {
+      createMemory: async () => true,
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    documentsManager: {
+      createMemory: async () => true,
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    knowledgeManager: {
+      createMemory: async () => true,
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    loreManager: {
+      createMemory: async () => true,
+      getMemories: async () => [],
+      getMemoriesByRoomIds: async () => [],
+      getCachedEmbeddings: async () => [],
+      searchMemoriesByEmbedding: async () => [],
+    },
+    useModel: async (modelType: any, params: any) => {
+      // Log model calls to see what's happening
+      elizaLogger.info('[Debug] Model called with:', {
+        modelType,
+        query: params?.messages?.[params.messages.length - 1]?.content
+      });
+      
+      // Return a simple response to avoid errors
+      return 'Based on the search results, here is a concise answer to your query.';
+    },
+    stop: async () => {},
+  } as any as IAgentRuntime;
+};
+
+async function debugResearch() {
+  elizaLogger.info('=== Starting Research Debug ===');
+  
+  const runtime = createTestRuntime();
+  const service = new ResearchService(runtime);
+  
+  const testQuery = "Compare the environmental and economic impacts of different renewable energy storage technologies for grid-scale deployment";
+  
+  elizaLogger.info(`Original Query: "${testQuery}"`);
+  
+  try {
+    // Create a research project
+    const project = await service.createResearchProject(testQuery, {
+      searchProviders: ['web'],
+      maxSearchResults: 5,
+      evaluationEnabled: false,
+    });
+    
+    elizaLogger.info('Project created:', {
+      id: project.id,
+      query: project.query,
+      status: project.status,
+      metadata: {
+        domain: project.metadata.domain,
+        taskType: project.metadata.taskType,
+        queryPlan: {
+          mainQuery: project.metadata.queryPlan.mainQuery,
+          subQueries: project.metadata.queryPlan.subQueries.map(sq => ({
+            query: sq.query,
+            purpose: sq.purpose,
+          })),
+        },
+      },
+    });
+    
+    // Wait a bit for the research to start
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // Check the project status
+    const updatedProject = await service.getProject(project.id);
+    
+    if (updatedProject) {
+      elizaLogger.info('Project after 2 seconds:', {
+        status: updatedProject.status,
+        phase: updatedProject.phase,
+        sources: updatedProject.sources.length,
+        findings: updatedProject.findings.length,
+      });
+      
+      // Log the first few sources if any
+      if (updatedProject.sources.length > 0) {
+        elizaLogger.info('First few sources found:', 
+          updatedProject.sources.slice(0, 3).map(s => ({
+            title: s.title,
+            url: s.url,
+          }))
+        );
+      }
+    }
+    
+    // Stop the service
+    await service.stop();
+    
+  } catch (error) {
+    elizaLogger.error('Debug failed:', error);
+  }
+  
+  elizaLogger.info('=== Debug Complete ===');
+}
+
+// Run the debug
+debugResearch().catch(console.error); 

package/src/examples/defi-code-scenarios.md

@@ -0,0 +1,536 @@
+# Deep Research Plugin - DeFi & Code Research Scenarios
+
+## DeFi Research Scenarios
+
+### 1. Smart Contract Security Analysis
+
+**Topic**: "Critical vulnerabilities in DeFi lending protocols 2024"
+
+#### Research Configuration
+```typescript
+const defiSecurityResearch = {
+  query: "DeFi lending protocol vulnerabilities reentrancy flash loan attacks 2024",
+  config: {
+    maxSearchResults: 25,
+    searchProviders: ['academic', 'security', 'github'],
+    enableCodeAnalysis: true,
+    prioritizeSources: ['audit reports', 'CVE databases', 'security blogs']
+  }
+};
+```
+
+#### Expected Research Flow
+1. **Planning Phase**: Identify major lending protocols (Aave, Compound, MakerDAO)
+2. **Searching Phase**: 
+   - Security audit reports from Certik, Trail of Bits, ConsenSys
+   - GitHub security advisories
+   - Immunefi bug bounty reports
+3. **Analyzing Phase**: Categorize vulnerabilities by severity and exploit type
+4. **Synthesizing Phase**: Create vulnerability taxonomy and mitigation strategies
+5. **Reporting Phase**: Generate security assessment with code examples
+
+#### Expected Findings
+```markdown
+## Critical DeFi Vulnerabilities Report
+
+### 1. Reentrancy Attacks in Lending Protocols
+- **Affected Protocols**: [List of vulnerable protocols]
+- **Severity**: Critical
+- **Example Code**:
+```solidity
+// Vulnerable pattern
+function withdraw(uint amount) external {
+    require(balances[msg.sender] >= amount);
+    (bool success, ) = msg.sender.call{value: amount}("");
+    require(success);
+    balances[msg.sender] -= amount; // State update after external call
+}
+```
+
+### 2. Oracle Manipulation Vectors
+- Flash loan price manipulation techniques
+- Time-weighted average price (TWAP) vulnerabilities
+- Mitigation strategies and secure oracle patterns
+```
+
+### 2. Yield Farming Strategy Optimization
+
+**Topic**: "Optimal yield farming strategies across Ethereum L2s comparative analysis"
+
+```typescript
+// Research configuration for yield optimization
+const yieldResearch = {
+  query: "Arbitrum Optimism Polygon zkSync yield farming APY comparison 2024",
+  config: {
+    maxSearchResults: 30,
+    includeMetrics: ['APY', 'TVL', 'risk scores', 'impermanent loss'],
+    timeframe: 'last_30_days',
+    chains: ['arbitrum', 'optimism', 'polygon', 'zksync']
+  }
+};
+```
+
+#### Research Objectives
+- Compare yield opportunities across L2 ecosystems
+- Analyze risk-adjusted returns
+- Identify sustainable vs. unsustainable yields
+- Gas cost optimization strategies
+
+#### Expected Deliverables
+1. **Yield Comparison Matrix**
+   ```
+   | Protocol | Chain    | APY    | TVL     | Risk | Gas Cost |
+   |----------|----------|--------|---------|------|----------|
+   | GMX      | Arbitrum | 15-25% | $450M   | Med  | $0.50    |
+   | Velodrome| Optimism | 20-40% | $300M   | High | $0.30    |
+   ```
+
+2. **Risk Assessment Framework**
+   - Smart contract risk scores
+   - Liquidity depth analysis
+   - Historical volatility metrics
+
+3. **Optimal Strategy Recommendations**
+   - Capital allocation models
+   - Rebalancing frequencies
+   - Cross-chain arbitrage opportunities
+
+### 3. MEV (Maximum Extractable Value) Research
+
+**Topic**: "MEV extraction strategies and protection mechanisms in DeFi"
+
+```typescript
+const mevResearch = {
+  query: "MEV sandwich attacks frontrunning protection Flashbots private mempools",
+  config: {
+    includeSources: ['research papers', 'MEV dashboards', 'protocol documentation'],
+    codeExamples: true,
+    realTimeData: true
+  }
+};
+```
+
+#### Research Areas
+1. **MEV Attack Vectors**
+   - Sandwich attacks on DEX trades
+   - Liquidation frontrunning
+   - Time-bandit attacks
+
+2. **Protection Mechanisms**
+   - Private mempools (Flashbots Protect)
+   - Commit-reveal schemes
+   - Fair ordering protocols
+
+3. **Code Implementation Examples**
+   ```solidity
+   // MEV Protection Pattern
+   contract MEVProtectedDEX {
+       mapping(bytes32 => uint256) private commitments;
+       uint256 constant COMMIT_PERIOD = 2 blocks;
+       
+       function commitTrade(bytes32 commitment) external {
+           commitments[commitment] = block.number;
+       }
+       
+       function revealAndExecute(
+           uint256 amountIn,
+           uint256 minAmountOut,
+           address tokenIn,
+           address tokenOut,
+           uint256 nonce
+       ) external {
+           bytes32 commitment = keccak256(
+               abi.encodePacked(msg.sender, amountIn, minAmountOut, tokenIn, tokenOut, nonce)
+           );
+           require(commitments[commitment] + COMMIT_PERIOD <= block.number, "Too early");
+           // Execute trade
+       }
+   }
+   ```
+
+## Code & Development Research Scenarios
+
+### 4. Solidity Gas Optimization Techniques
+
+**Topic**: "Advanced Solidity gas optimization patterns and assembly tricks 2024"
+
+```typescript
+const gasOptimizationResearch = {
+  query: "Solidity gas optimization assembly inline yul storage packing bitwise operations",
+  config: {
+    focusAreas: ['storage optimization', 'computation efficiency', 'calldata optimization'],
+    includeCodeSnippets: true,
+    benchmarkData: true
+  }
+};
+```
+
+#### Expected Research Output
+
+```markdown
+## Solidity Gas Optimization Guide
+
+### 1. Storage Packing Optimization
+```solidity
+// Before: 3 storage slots (96,000 gas)
+contract Inefficient {
+    uint256 a;  // Slot 0
+    uint128 b;  // Slot 1
+    uint128 c;  // Slot 2
+}
+
+// After: 2 storage slots (64,000 gas)
+contract Optimized {
+    uint256 a;  // Slot 0
+    uint128 b;  // Slot 1 (packed)
+    uint128 c;  // Slot 1 (packed)
+}
+```
+
+### 2. Assembly Optimization Patterns
+```solidity
+// Memory-efficient array operations
+function sumArray(uint256[] calldata arr) external pure returns (uint256 sum) {
+    assembly {
+        let len := calldataload(add(arr.offset, sub(0, 0x20)))
+        let data := arr.offset
+        for { let i := 0 } lt(i, len) { i := add(i, 1) } {
+            sum := add(sum, calldataload(add(data, mul(i, 0x20))))
+        }
+    }
+}
+```
+
+### 3. Bitwise Operations for Flag Management
+```solidity
+// Using single uint256 for 256 boolean flags
+uint256 private flags;
+
+function setFlag(uint8 index, bool value) external {
+    if (value) {
+        flags |= (1 << index);  // Set bit
+    } else {
+        flags &= ~(1 << index); // Clear bit
+    }
+}
+```
+```
+
+### 5. Cross-Chain Bridge Architecture Analysis
+
+**Topic**: "Secure cross-chain bridge implementations: Architecture patterns and vulnerabilities"
+
+```typescript
+const bridgeResearch = {
+  query: "cross-chain bridge architecture security LayerZero Wormhole Axelar implementation",
+  config: {
+    technicalDepth: 'deep',
+    includeArchitectureDiagrams: true,
+    securityFocus: ['validator sets', 'message verification', 'liquidity management']
+  }
+};
+```
+
+#### Research Deliverables
+
+1. **Architecture Comparison**
+   ```mermaid
+   graph TD
+     A[User on Chain A] --> B[Bridge Contract A]
+     B --> C{Validator Network}
+     C --> D[Bridge Contract B]
+     D --> E[User on Chain B]
+     
+     subgraph "Security Layers"
+       F[Message Hashing]
+       G[Multi-Sig Validation]
+       H[Time Locks]
+       I[Fraud Proofs]
+     end
+   ```
+
+2. **Implementation Patterns**
+   ```typescript
+   interface CrossChainMessage {
+     sourceChain: string;
+     destChain: string;
+     nonce: bigint;
+     sender: Address;
+     receiver: Address;
+     payload: Bytes;
+     signatures: Signature[];
+   }
+   
+   class BridgeValidator {
+     async validateMessage(message: CrossChainMessage): Promise<boolean> {
+       // Verify signatures
+       const signers = await this.recoverSigners(message);
+       
+       // Check if enough validators signed
+       const validSigners = signers.filter(s => this.isValidator(s));
+       return validSigners.length >= this.requiredSignatures;
+     }
+   }
+   ```
+
+### 6. Zero-Knowledge Proof Implementation Research
+
+**Topic**: "Implementing ZK proofs in DeFi: Privacy-preserving trading and compliance"
+
+```typescript
+const zkResearch = {
+  query: "zero knowledge proofs DeFi implementation Tornado Cash privacy DEX zk-SNARKs Circom",
+  config: {
+    includeImplementations: ['Circom circuits', 'Solidity verifiers', 'client libraries'],
+    useCases: ['private trading', 'compliant privacy', 'proof of solvency'],
+    performanceMetrics: true
+  }
+};
+```
+
+#### Expected Research Findings
+
+```javascript
+// Example: Private Balance Proof Circuit
+pragma circom 2.0.0;
+
+template PrivateBalance() {
+    signal input balance;
+    signal input commitment;
+    signal input nullifier;
+    signal output validProof;
+    
+    // Commitment = Poseidon(balance, nullifier)
+    component hasher = Poseidon(2);
+    hasher.inputs[0] <== balance;
+    hasher.inputs[1] <== nullifier;
+    
+    // Verify commitment matches
+    validProof <== hasher.out - commitment;
+    validProof === 0;
+}
+
+// Corresponding Solidity Verifier
+contract PrivateBalanceVerifier {
+    function verifyProof(
+        uint256[2] memory a,
+        uint256[2][2] memory b,
+        uint256[2] memory c,
+        uint256[1] memory input
+    ) public view returns (bool) {
+        // Groth16 verification logic
+    }
+}
+```
+
+### 7. DeFi Protocol Integration Patterns
+
+**Topic**: "Best practices for composable DeFi protocol integration and adapter patterns"
+
+```typescript
+const integrationResearch = {
+  query: "DeFi composability adapter pattern protocol integration Uniswap Aave Compound interfaces",
+  config: {
+    patterns: ['adapter', 'proxy', 'diamond', 'plugin'],
+    examples: ['flash loan arbitrage', 'yield aggregation', 'leveraged farming'],
+    gasAnalysis: true
+  }
+};
+```
+
+#### Integration Pattern Examples
+
+```solidity
+// Universal DeFi Adapter Pattern
+interface IDeFiAdapter {
+    function deposit(address asset, uint256 amount) external returns (uint256 shares);
+    function withdraw(address asset, uint256 shares) external returns (uint256 amount);
+    function getBalance(address user, address asset) external view returns (uint256);
+    function getAPY(address asset) external view returns (uint256);
+}
+
+// Aave Adapter Implementation
+contract AaveAdapter is IDeFiAdapter {
+    ILendingPool constant aave = ILendingPool(0x...);
+    
+    function deposit(address asset, uint256 amount) external returns (uint256) {
+        IERC20(asset).transferFrom(msg.sender, address(this), amount);
+        IERC20(asset).approve(address(aave), amount);
+        aave.deposit(asset, amount, msg.sender, 0);
+        return IERC20(aToken[asset]).balanceOf(msg.sender);
+    }
+}
+
+// Composable Yield Optimizer
+contract YieldOptimizer {
+    mapping(string => IDeFiAdapter) public adapters;
+    
+    function rebalance(string[] memory protocols, uint256[] memory allocations) external {
+        // Withdraw from all positions
+        // Recalculate optimal allocation
+        // Deposit to new positions
+    }
+}
+```
+
+### 8. Real-time DeFi Analytics Pipeline
+
+**Topic**: "Building real-time DeFi analytics: Event processing and data pipeline architecture"
+
+```typescript
+const analyticsResearch = {
+  query: "DeFi analytics real-time event processing The Graph Protocol Dune Analytics architecture",
+  config: {
+    technologies: ['event streaming', 'GraphQL', 'time-series databases'],
+    metrics: ['TVL tracking', 'volume analysis', 'user behavior', 'risk metrics'],
+    scalability: 'high'
+  }
+};
+```
+
+#### Analytics Architecture
+
+```typescript
+// Event Processing Pipeline
+class DeFiEventProcessor {
+  private eventQueue: Queue<ContractEvent>;
+  private processors: Map<string, EventProcessor>;
+  
+  async processBlock(blockNumber: number) {
+    const events = await this.fetchBlockEvents(blockNumber);
+    
+    for (const event of events) {
+      const processor = this.processors.get(event.name);
+      if (processor) {
+        const metric = await processor.process(event);
+        await this.publishMetric(metric);
+      }
+    }
+  }
+}
+
+// GraphQL Schema for DeFi Analytics
+type DeFiProtocol {
+  id: ID!
+  name: String!
+  tvl: BigDecimal!
+  volume24h: BigDecimal!
+  users24h: Int!
+  pools: [LiquidityPool!]!
+  historicalData(first: Int, skip: Int): [ProtocolDayData!]!
+}
+
+type LiquidityPool {
+  id: ID!
+  token0: Token!
+  token1: Token!
+  reserve0: BigDecimal!
+  reserve1: BigDecimal!
+  volumeUSD: BigDecimal!
+  apr: BigDecimal!
+}
+```
+
+## Advanced Research Combinations
+
+### 9. AI-Powered Smart Contract Auditing
+
+**Topic**: "Machine learning approaches to smart contract vulnerability detection"
+
+```typescript
+const aiAuditResearch = {
+  query: "ML smart contract audit vulnerability detection neural networks static analysis Slither",
+  config: {
+    approaches: ['static analysis', 'symbolic execution', 'deep learning'],
+    datasets: ['verified contracts', 'known vulnerabilities', 'audit reports'],
+    tools: ['Slither', 'Mythril', 'ML frameworks']
+  }
+};
+```
+
+### 10. Decentralized Orderbook Implementation
+
+**Topic**: "High-performance decentralized orderbook designs for DeFi"
+
+```typescript
+const orderbookResearch = {
+  query: "decentralized orderbook implementation Serum dYdX performance optimization L2",
+  config: {
+    focus: ['data structures', 'matching algorithms', 'state management'],
+    performance: ['latency', 'throughput', 'gas efficiency'],
+    examples: ['on-chain', 'hybrid', 'rollup-based']
+  }
+};
+```
+
+## Research Integration Examples
+
+### Automated Research Pipeline for DeFi Protocols
+
+```typescript
+// Automated weekly DeFi protocol research
+async function automatedDeFiResearch(runtime: IAgentRuntime) {
+  const protocols = ['Uniswap', 'Aave', 'Curve', 'Compound', 'MakerDAO'];
+  const researchService = runtime.getService<ResearchService>('research');
+  
+  for (const protocol of protocols) {
+    // Security research
+    const securityProject = await researchService.createResearchProject(
+      `${protocol} security vulnerabilities exploits 2024`,
+      { maxSearchResults: 20 }
+    );
+    
+    // Performance research
+    const performanceProject = await researchService.createResearchProject(
+      `${protocol} gas optimization performance improvements`,
+      { maxSearchResults: 15 }
+    );
+    
+    // Integration research
+    const integrationProject = await researchService.createResearchProject(
+      `${protocol} integration patterns composability best practices`,
+      { maxSearchResults: 10 }
+    );
+  }
+  
+  // Generate comparative report
+  await generateComparativeReport(protocols);
+}
+```
+
+### Real-time Vulnerability Monitoring
+
+```typescript
+// Monitor for new DeFi vulnerabilities
+class DeFiSecurityMonitor {
+  constructor(private researchService: ResearchService) {}
+  
+  async monitorVulnerabilities() {
+    const criticalTerms = [
+      'critical vulnerability',
+      'exploit',
+      'hack',
+      'security incident',
+      'emergency pause'
+    ];
+    
+    for (const term of criticalTerms) {
+      const project = await this.researchService.createResearchProject(
+        `DeFi ${term} last 24 hours`,
+        {
+          maxSearchResults: 50,
+          timeframe: '24h',
+          priority: 'high'
+        }
+      );
+      
+      // Alert on critical findings
+      project.on('finding', (finding) => {
+        if (finding.relevance > 0.9) {
+          this.sendSecurityAlert(finding);
+        }
+      });
+    }
+  }
+}
+```