@framers/agentos-ext-web-search 1.1.0 → 1.2.0

package/src/tools/factCheck.ts

@@ -1,318 +0,0 @@
-import { ITool } from '@framers/agentos';
-import { SearchProviderService } from '../services/searchProvider';
-
-/**
- * Fact checking tool that verifies statements against web sources
- * 
- * @class FactCheckTool
- * @implements {ITool}
- * 
- * @example
- * ```typescript
- * const tool = new FactCheckTool(searchService);
- * const result = await tool.execute({
- *   statement: 'The Earth orbits the Sun',
- *   checkSources: true,
- *   confidence: 'high'
- * });
- * ```
- */
-export class FactCheckTool implements ITool {
-  public readonly id = 'factCheck';
-  public readonly name = 'Fact Check';
-  public readonly description = 'Verify facts and statements against web sources';
-  
-  /**
-   * Creates an instance of FactCheckTool
-   * @param {SearchProviderService} searchService - The search provider service
-   */
-  constructor(private searchService: SearchProviderService) {}
-  
-  /**
-   * Executes fact checking on a statement
-   * 
-   * @param {Object} input - The fact check parameters
-   * @param {string} input.statement - The statement to fact-check
-   * @param {boolean} [input.checkSources=true] - Whether to include source citations
-   * @param {string} [input.confidence='medium'] - Required confidence level
-   * @returns {Promise<{success: boolean, output?: any, error?: string}>} Fact check results
-   */
-  async execute(input: {
-    statement: string;
-    checkSources?: boolean;
-    confidence?: 'low' | 'medium' | 'high';
-  }): Promise<{ success: boolean; output?: any; error?: string }> {
-    try {
-      const checkSources = input.checkSources !== false;
-      const requiredConfidence = input.confidence || 'medium';
-      
-      // Search for information about the statement
-      const queries = this.generateFactCheckQueries(input.statement);
-      
-      // Perform searches in parallel
-      const searchPromises = queries.map(query => 
-        this.searchService.search(query, { maxResults: 5 })
-          .catch(err => ({ 
-            provider: 'error', 
-            results: [], 
-            metadata: { query, error: err.message, timestamp: new Date().toISOString() }
-          }))
-      );
-      
-      const searchResults = await Promise.all(searchPromises);
-      
-      // Analyze results for fact verification
-      const analysis = this.analyzeFactCheckResults(
-        input.statement, 
-        searchResults,
-        requiredConfidence
-      );
-      
-      // Compile sources if requested
-      const sources = checkSources ? this.compileSources(searchResults) : [];
-      
-      return {
-        success: true,
-        output: {
-          statement: input.statement,
-          verdict: analysis.verdict,
-          confidence: analysis.confidence,
-          explanation: analysis.explanation,
-          sources: sources,
-          contradictingSources: analysis.contradictingSources,
-          supportingSources: analysis.supportingSources,
-          timestamp: new Date().toISOString()
-        }
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-  
-  /**
-   * Generates queries for fact-checking a statement
-   * 
-   * @private
-   * @param {string} statement - The statement to check
-   * @returns {string[]} Array of search queries
-   */
-  private generateFactCheckQueries(statement: string): string[] {
-    return [
-      statement, // Original statement
-      `"${statement}" fact check`, // Exact match with fact check
-      `${statement} true or false`, // Truth verification
-      `${statement} debunked myths`, // Check for debunking
-      `is it true that ${statement}` // Question format
-    ];
-  }
-  
-  /**
-   * Analyzes search results to determine fact validity
-   * 
-   * @private
-   * @param {string} statement - Original statement
-   * @param {any[]} searchResults - Search results to analyze
-   * @param {string} requiredConfidence - Required confidence level
-   * @returns {Object} Analysis results with verdict and confidence
-   */
-  private analyzeFactCheckResults(
-    statement: string, 
-    searchResults: any[],
-    requiredConfidence: string
-  ): any {
-    let supportingCount = 0;
-    let contradictingCount = 0;
-    let neutralCount = 0;
-    const supportingSources: string[] = [];
-    const contradictingSources: string[] = [];
-    
-    const statementLower = statement.toLowerCase();
-    const negativeIndicators = ['false', 'myth', 'debunked', 'incorrect', 'wrong', 'not true', 'fake'];
-    const positiveIndicators = ['true', 'correct', 'accurate', 'confirmed', 'verified', 'fact'];
-    
-    for (const searchResult of searchResults) {
-      if (!searchResult.results) continue;
-      
-      for (const result of searchResult.results) {
-        const contentLower = (result.title + ' ' + result.snippet).toLowerCase();
-        
-        // Check for fact-checking sites
-        const isFactCheckSite = result.url.includes('snopes') || 
-                                result.url.includes('factcheck') || 
-                                result.url.includes('politifact');
-        
-        const weight = isFactCheckSite ? 2 : 1; // Give more weight to fact-checking sites
-        
-        // Analyze sentiment toward the statement
-        let hasNegative = negativeIndicators.some(ind => contentLower.includes(ind));
-        let hasPositive = positiveIndicators.some(ind => contentLower.includes(ind));
-        
-        if (hasNegative && !hasPositive) {
-          contradictingCount += weight;
-          contradictingSources.push(result.url);
-        } else if (hasPositive && !hasNegative) {
-          supportingCount += weight;
-          supportingSources.push(result.url);
-        } else {
-          neutralCount += 1;
-        }
-      }
-    }
-    
-    // Calculate confidence and verdict
-    const total = supportingCount + contradictingCount + neutralCount;
-    let confidence: number;
-    let verdict: 'TRUE' | 'FALSE' | 'UNVERIFIED' | 'PARTIALLY TRUE';
-    let explanation: string;
-    
-    if (total === 0) {
-      verdict = 'UNVERIFIED';
-      confidence = 0;
-      explanation = 'No relevant sources found to verify this statement.';
-    } else {
-      const supportRatio = supportingCount / total;
-      const contradictRatio = contradictingCount / total;
-      
-      if (supportRatio > 0.7) {
-        verdict = 'TRUE';
-        confidence = supportRatio * 100;
-        explanation = `Strong evidence supports this statement (${supportingCount} supporting sources).`;
-      } else if (contradictRatio > 0.7) {
-        verdict = 'FALSE';
-        confidence = contradictRatio * 100;
-        explanation = `Strong evidence contradicts this statement (${contradictingCount} contradicting sources).`;
-      } else if (supportRatio > 0.4 && contradictRatio > 0.4) {
-        verdict = 'PARTIALLY TRUE';
-        confidence = 50;
-        explanation = `Mixed evidence with both supporting and contradicting sources.`;
-      } else {
-        verdict = 'UNVERIFIED';
-        confidence = Math.max(supportRatio, contradictRatio) * 100;
-        explanation = `Insufficient clear evidence to verify this statement.`;
-      }
-    }
-    
-    // Adjust confidence based on required level
-    const confidenceLevel = confidence > 80 ? 'high' : confidence > 50 ? 'medium' : 'low';
-    
-    return {
-      verdict,
-      confidence: Math.round(confidence),
-      confidenceLevel,
-      explanation,
-      supportingSources: supportingSources.slice(0, 5),
-      contradictingSources: contradictingSources.slice(0, 5),
-      meetsRequiredConfidence: this.meetsConfidenceRequirement(confidenceLevel, requiredConfidence)
-    };
-  }
-  
-  /**
-   * Checks if confidence level meets requirement
-   * 
-   * @private
-   * @param {string} actual - Actual confidence level
-   * @param {string} required - Required confidence level
-   * @returns {boolean} True if requirement is met
-   */
-  private meetsConfidenceRequirement(actual: string, required: string): boolean {
-    const levels = { low: 1, medium: 2, high: 3 };
-    return levels[actual as keyof typeof levels] >= levels[required as keyof typeof levels];
-  }
-  
-  /**
-   * Compiles relevant sources from search results
-   * 
-   * @private
-   * @param {any[]} searchResults - Search results to compile from
-   * @returns {any[]} Compiled sources with metadata
-   */
-  private compileSources(searchResults: any[]): any[] {
-    const sources: any[] = [];
-    const seenUrls = new Set<string>();
-    
-    for (const searchResult of searchResults) {
-      if (!searchResult.results) continue;
-      
-      for (const result of searchResult.results) {
-        if (seenUrls.has(result.url)) continue;
-        seenUrls.add(result.url);
-        
-        sources.push({
-          title: result.title,
-          url: result.url,
-          snippet: result.snippet,
-          provider: searchResult.provider,
-          query: searchResult.metadata.query
-        });
-      }
-    }
-    
-    return sources.slice(0, 10); // Limit to top 10 sources
-  }
-  
-  /**
-   * Validates input parameters
-   * 
-   * @param {any} input - Input to validate
-   * @returns {{valid: boolean, errors: string[]}} Validation result
-   */
-  validate(input: any): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-    
-    if (!input.statement) {
-      errors.push('Statement is required');
-    } else if (typeof input.statement !== 'string') {
-      errors.push('Statement must be a string');
-    } else if (input.statement.length < 5) {
-      errors.push('Statement must be at least 5 characters long');
-    }
-    
-    if (input.confidence !== undefined) {
-      if (!['low', 'medium', 'high'].includes(input.confidence)) {
-        errors.push('Confidence must be low, medium, or high');
-      }
-    }
-    
-    if (input.checkSources !== undefined && typeof input.checkSources !== 'boolean') {
-      errors.push('checkSources must be a boolean');
-    }
-    
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  
-  /**
-   * Returns the JSON schema for the tool's input
-   * 
-   * @returns {Object} JSON Schema object
-   */
-  getSchema(): any {
-    return {
-      type: 'object',
-      required: ['statement'],
-      properties: {
-        statement: {
-          type: 'string',
-          description: 'The statement to fact-check',
-          minLength: 5
-        },
-        checkSources: {
-          type: 'boolean',
-          description: 'Whether to include source citations',
-          default: true
-        },
-        confidence: {
-          type: 'string',
-          description: 'Required confidence level for the verdict',
-          enum: ['low', 'medium', 'high'],
-          default: 'medium'
-        }
-      }
-    };
-  }
-}

package/src/tools/researchAggregator.ts

@@ -1,297 +0,0 @@
-import { ITool } from '@framers/agentos';
-import { SearchProviderService } from '../services/searchProvider';
-
-/**
- * Research aggregator tool that performs multiple searches and synthesizes results
- * 
- * @class ResearchAggregatorTool
- * @implements {ITool}
- * 
- * @example
- * ```typescript
- * const tool = new ResearchAggregatorTool(searchService);
- * const result = await tool.execute({
- *   topic: 'AI safety research',
- *   sources: 3,
- *   depth: 'comprehensive'
- * });
- * ```
- */
-export class ResearchAggregatorTool implements ITool {
-  public readonly id = 'researchAggregator';
-  public readonly name = 'Research Aggregator';
-  public readonly description = 'Aggregate research from multiple searches on a topic';
-  
-  /**
-   * Creates an instance of ResearchAggregatorTool
-   * @param {SearchProviderService} searchService - The search provider service
-   */
-  constructor(private searchService: SearchProviderService) {}
-  
-  /**
-   * Executes research aggregation on a topic
-   * 
-   * @param {Object} input - The research parameters
-   * @param {string} input.topic - The research topic
-   * @param {number} [input.sources=3] - Number of different search angles to explore
-   * @param {string} [input.depth='moderate'] - Research depth (quick, moderate, comprehensive)
-   * @returns {Promise<{success: boolean, output?: any, error?: string}>} Aggregated research results
-   */
-  async execute(input: {
-    topic: string;
-    sources?: number;
-    depth?: 'quick' | 'moderate' | 'comprehensive';
-  }): Promise<{ success: boolean; output?: any; error?: string }> {
-    try {
-      const sources = input.sources || 3;
-      const depth = input.depth || 'moderate';
-      
-      // Generate different search queries for comprehensive coverage
-      const queries = this.generateSearchQueries(input.topic, sources, depth);
-      
-      // Perform searches in parallel
-      const searchPromises = queries.map(query => 
-        this.searchService.search(query, {
-          maxResults: depth === 'quick' ? 5 : depth === 'moderate' ? 10 : 15
-        }).catch(err => ({ 
-          provider: 'error', 
-          results: [], 
-          metadata: { query, error: err.message, timestamp: new Date().toISOString() }
-        }))
-      );
-      
-      const searchResults = await Promise.all(searchPromises);
-      
-      // Aggregate and deduplicate results
-      const aggregated = this.aggregateResults(searchResults, input.topic);
-      
-      return {
-        success: true,
-        output: {
-          topic: input.topic,
-          sources: sources,
-          depth: depth,
-          queries: queries,
-          aggregatedResults: aggregated,
-          timestamp: new Date().toISOString()
-        }
-      };
-    } catch (error: any) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-  
-  /**
-   * Generates diverse search queries for comprehensive research
-   * 
-   * @private
-   * @param {string} topic - The research topic
-   * @param {number} count - Number of queries to generate
-   * @param {string} depth - Research depth level
-   * @returns {string[]} Array of search queries
-   */
-  private generateSearchQueries(topic: string, count: number, depth: string): string[] {
-    const queries: string[] = [topic]; // Start with the original topic
-    
-    const modifiers = {
-      quick: ['overview', 'summary'],
-      moderate: ['overview', 'recent developments', 'key concepts', 'applications'],
-      comprehensive: [
-        'overview',
-        'recent research',
-        'state of the art',
-        'challenges',
-        'future directions',
-        'industry applications',
-        'academic papers',
-        'expert opinions'
-      ]
-    };
-    
-    const selectedModifiers = modifiers[depth as keyof typeof modifiers];
-    
-    for (let i = 1; i < Math.min(count, selectedModifiers.length + 1); i++) {
-      if (selectedModifiers[i - 1]) {
-        queries.push(`${topic} ${selectedModifiers[i - 1]}`);
-      }
-    }
-    
-    return queries;
-  }
-  
-  /**
-   * Aggregates and deduplicates search results
-   * 
-   * @private
-   * @param {any[]} searchResults - Array of search results from different queries
-   * @param {string} topic - The original research topic
-   * @returns {Object} Aggregated and organized results
-   */
-  private aggregateResults(searchResults: any[], topic: string): any {
-    const seenUrls = new Set<string>();
-    const categories = {
-      overview: [] as any[],
-      research: [] as any[],
-      applications: [] as any[],
-      resources: [] as any[]
-    };
-    
-    for (const searchResult of searchResults) {
-      if (!searchResult.results) continue;
-      
-      for (const result of searchResult.results) {
-        // Skip duplicates
-        if (seenUrls.has(result.url)) continue;
-        seenUrls.add(result.url);
-        
-        // Categorize based on content
-        const lowerTitle = result.title.toLowerCase();
-        const lowerSnippet = result.snippet.toLowerCase();
-        
-        if (lowerTitle.includes('overview') || lowerTitle.includes('introduction') || 
-            lowerTitle.includes('what is')) {
-          categories.overview.push(result);
-        } else if (lowerTitle.includes('research') || lowerTitle.includes('study') || 
-                   lowerTitle.includes('paper') || lowerTitle.includes('journal')) {
-          categories.research.push(result);
-        } else if (lowerTitle.includes('application') || lowerTitle.includes('use case') || 
-                   lowerTitle.includes('implementation')) {
-          categories.applications.push(result);
-        } else {
-          categories.resources.push(result);
-        }
-      }
-    }
-    
-    // Calculate relevance scores
-    const scoredCategories = Object.entries(categories).reduce((acc, [key, items]) => {
-      acc[key] = items.map((item: any) => ({
-        ...item,
-        relevanceScore: this.calculateRelevance(item, topic)
-      })).sort((a: any, b: any) => b.relevanceScore - a.relevanceScore);
-      return acc;
-    }, {} as any);
-    
-    return {
-      categories: scoredCategories,
-      totalResults: seenUrls.size,
-      topResults: this.getTopResults(scoredCategories, 10)
-    };
-  }
-  
-  /**
-   * Calculates relevance score for a search result
-   * 
-   * @private
-   * @param {any} result - Search result object
-   * @param {string} topic - Original topic for comparison
-   * @returns {number} Relevance score (0-100)
-   */
-  private calculateRelevance(result: any, topic: string): number {
-    let score = 50; // Base score
-    
-    const topicWords = topic.toLowerCase().split(/\s+/);
-    const titleWords = result.title.toLowerCase();
-    const snippetWords = result.snippet.toLowerCase();
-    
-    // Check title relevance
-    for (const word of topicWords) {
-      if (titleWords.includes(word)) score += 15;
-      if (snippetWords.includes(word)) score += 5;
-    }
-    
-    // Boost for certain indicators
-    if (titleWords.includes('official')) score += 10;
-    if (titleWords.includes('guide')) score += 5;
-    if (titleWords.includes('tutorial')) score += 5;
-    
-    return Math.min(100, score);
-  }
-  
-  /**
-   * Gets top results across all categories
-   * 
-   * @private
-   * @param {any} categories - Categorized results
-   * @param {number} count - Number of top results to return
-   * @returns {any[]} Top results by relevance
-   */
-  private getTopResults(categories: any, count: number): any[] {
-    const allResults: any[] = [];
-    
-    for (const items of Object.values(categories)) {
-      allResults.push(...(items as any[]));
-    }
-    
-    return allResults
-      .sort((a, b) => b.relevanceScore - a.relevanceScore)
-      .slice(0, count);
-  }
-  
-  /**
-   * Validates input parameters
-   * 
-   * @param {any} input - Input to validate
-   * @returns {{valid: boolean, errors: string[]}} Validation result
-   */
-  validate(input: any): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-    
-    if (!input.topic) {
-      errors.push('Topic is required');
-    } else if (typeof input.topic !== 'string') {
-      errors.push('Topic must be a string');
-    }
-    
-    if (input.sources !== undefined) {
-      if (typeof input.sources !== 'number' || input.sources < 1 || input.sources > 10) {
-        errors.push('Sources must be a number between 1 and 10');
-      }
-    }
-    
-    if (input.depth !== undefined) {
-      if (!['quick', 'moderate', 'comprehensive'].includes(input.depth)) {
-        errors.push('Depth must be quick, moderate, or comprehensive');
-      }
-    }
-    
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  
-  /**
-   * Returns the JSON schema for the tool's input
-   * 
-   * @returns {Object} JSON Schema object
-   */
-  getSchema(): any {
-    return {
-      type: 'object',
-      required: ['topic'],
-      properties: {
-        topic: {
-          type: 'string',
-          description: 'The research topic to aggregate information about'
-        },
-        sources: {
-          type: 'number',
-          description: 'Number of different search angles to explore',
-          default: 3,
-          minimum: 1,
-          maximum: 10
-        },
-        depth: {
-          type: 'string',
-          description: 'Research depth level',
-          enum: ['quick', 'moderate', 'comprehensive'],
-          default: 'moderate'
-        }
-      }
-    };
-  }
-}