@gotza02/sequential-thinking 10000.0.0 → 10000.0.2

package/dist/tools/sports/providers/scraper.js

@@ -85,19 +85,62 @@ export class ScraperProvider extends ScraperProviderBase {
         }
     }
     /**
-     * Specialized extractor for Understat (Example)
+     * Specialized extractor for Understat
+     * Extracts xG, shots, and other advanced metrics from the JSON data embedded in script tags.
      */
     extractUnderstatData(html) {
         const dom = new JSDOM(html);
         const title = dom.window.document.title;
-        // Understat stores data in JSON strings within <script> tags
-        // This is a placeholder for actual regex-based JSON extraction
-        const scripts = Array.from(dom.window.document.querySelectorAll('script'));
-        const dataScript = scripts.find(s => s.textContent?.includes('JSON.parse'));
-        if (dataScript) {
-            return `## Understat Analysis: ${title}\n\n[Advanced xG Data Extracted from Script Tags]\nMatches, xG, xGA, and player positions parsed successfully.`;
+        let output = `## Understat Analysis: ${title}\n\n`;
+        // Helper to extract JSON from script variables
+        const extractJson = (varName) => {
+            const scripts = Array.from(dom.window.document.querySelectorAll('script'));
+            for (const script of scripts) {
+                const content = script.textContent || '';
+                const regex = new RegExp(`var ${varName}\\s*=\\s*JSON\\.parse\\('([^']+)'\\)`);
+                const match = content.match(regex);
+                if (match && match[1]) {
+                    try {
+                        // Decode hex sequences if any (Understat sometimes uses hex encoding)
+                        const jsonString = match[1].replace(/\\x([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+                        return JSON.parse(jsonString);
+                    }
+                    catch (e) {
+                        return null;
+                    }
+                }
+            }
+            return null;
+        };
+        const matchData = extractJson('match_info');
+        const rosterData = extractJson('rostersData');
+        if (matchData) {
+            output += `### Match Overview\n`;
+            output += `**Team:** ${matchData.h_team} vs ${matchData.a_team}\n`;
+            output += `**Score:** ${matchData.h_goals} - ${matchData.a_goals}\n`;
+            output += `**xG:** ${matchData.h_xg} - ${matchData.a_xg}\n`;
+            output += `**Probabilities:** Home Win: ${matchData.h_win}, Draw: ${matchData.draw}, Away Win: ${matchData.a_win}\n\n`;
         }
-        return `Title: ${title}\n\n(Understat specialized extraction fallback)`;
+        if (rosterData) {
+            output += `### Key Player Stats (xG > 0.1)\n`;
+            const processPlayers = (players, teamName) => {
+                output += `**${teamName}:**\n`;
+                Object.values(players).forEach((p) => {
+                    if (parseFloat(p.xG) > 0.1) {
+                        output += `- ${p.player}: xG ${p.xG}, xA ${p.xA}, Shots: ${p.shots}\n`;
+                    }
+                });
+                output += '\n';
+            };
+            if (rosterData.h)
+                processPlayers(rosterData.h, matchData?.h_team || 'Home');
+            if (rosterData.a)
+                processPlayers(rosterData.a, matchData?.a_team || 'Away');
+        }
+        if (!matchData && !rosterData) {
+            return `Title: ${title}\n\n(Understat extraction failed - JSON data not found)`;
+        }
+        return output;
     }
     /**
      * Specialized extractor for WhoScored (Example)
@@ -216,3 +259,15 @@ export function findBestMatchUrl(urls) {
     // Return first URL if no priority match
     return urls[0] || null;
 }
+/**
+ * Find best URL for news/lineups from search results
+ */
+export function findBestNewsUrl(urls) {
+    const newsDomains = SCRAPER_CONFIG.NEWS_DOMAINS;
+    for (const url of urls) {
+        if (newsDomains.some(domain => url.includes(domain))) {
+            return url;
+        }
+    }
+    return null;
+}

package/dist/tools/sports/tools/match.js

@@ -5,7 +5,7 @@
 import { z } from 'zod';
 import { createAPIProvider } from '../providers/api.js';
 import { getSearchProvider } from '../providers/search.js';
-import { scrapeMatchContent, findBestMatchUrl } from '../providers/scraper.js';
+import { scrapeMatchContent, findBestMatchUrl, findBestNewsUrl } from '../providers/scraper.js';
 import { getGlobalCache, CacheService } from '../core/cache.js';
 import { formatMatchesTable, formatScore, formatMatchStatus } from '../utils/formatter.js';
 import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
@@ -76,7 +76,7 @@ async function performMatchAnalysis(homeTeam, awayTeam, league, context) {
         { type: 'form', query: `${homeTeam} ${awayTeam} recent form last 5 matches${dateQuery}`, title: 'Recent Form' },
         { type: 'news', query: `${baseQuery} team news injuries lineups${dateQuery}`, title: 'Team News & Lineups' },
         { type: 'stats', query: `${baseQuery} xG expected goals stats${dateQuery}`, title: 'Advanced Metrics' },
-        { type: 'odds', query: `${baseQuery} odds movement dropping odds${dateQuery}`, title: 'Market & Odds' },
+        { type: 'odds', query: `${baseQuery} Asian Handicap odds prediction today${dateQuery}`, title: 'Latest Handicap Odds' },
         { type: 'fatigue', query: `${homeTeam} ${awayTeam} days rest fixture congestion${dateQuery}`, title: 'Fatigue & Schedule' },
         { type: 'setpieces', query: `${baseQuery} set pieces corners aerial duels${dateQuery}`, title: 'Set Pieces' },
     ];
@@ -111,24 +111,45 @@ async function performMatchAnalysis(homeTeam, awayTeam, league, context) {
         const batchResults = await Promise.all(batchPromises);
         combinedResults += batchResults.join('\n');
     }
-    // Deep dive: Scrape the best URL
+    // Deep dive: Scrape the best URLs (Dual-Source Strategy)
     if (candidateUrls.length > 0) {
-        const bestUrl = findBestMatchUrl(candidateUrls);
-        if (bestUrl) {
-            combinedResults += `\n--- DEEP DIVE ANALYSIS (${bestUrl}) ---\n`;
+        const bestStatsUrl = findBestMatchUrl(candidateUrls);
+        const bestNewsUrl = findBestNewsUrl(candidateUrls);
+        // 1. Scrape Stats Source (Priority)
+        if (bestStatsUrl) {
+            combinedResults += `\n--- DEEP DIVE ANALYSIS: STATS & DATA (${bestStatsUrl}) ---\n`;
             try {
-                const scrapedContent = await scrapeMatchContent(bestUrl);
+                const scrapedContent = await scrapeMatchContent(bestStatsUrl);
                 if (scrapedContent.success) {
                     combinedResults += scrapedContent.data || '';
                 }
                 else {
-                    combinedResults += `(Deep dive failed: ${scrapedContent.error})`;
+                    combinedResults += `(Stats scrape failed: ${scrapedContent.error})`;
                 }
             }
             catch (scrapeError) {
-                combinedResults += `(Deep dive failed: ${scrapeError instanceof Error ? scrapeError.message : String(scrapeError)})`;
+                combinedResults += `(Stats scrape failed: ${scrapeError instanceof Error ? scrapeError.message : String(scrapeError)})`;
             }
-            combinedResults += `\n--- END DEEP DIVE ---\n`;
+            combinedResults += `\n--- END STATS ---\n`;
+        }
+        // 2. Scrape News Source (if different from stats)
+        if (bestNewsUrl && bestNewsUrl !== bestStatsUrl) {
+            combinedResults += `\n--- DEEP DIVE ANALYSIS: NEWS & LINEUPS (${bestNewsUrl}) ---\n`;
+            try {
+                const scrapedContent = await scrapeMatchContent(bestNewsUrl);
+                if (scrapedContent.success) {
+                    // Truncate news to avoid blowing up context, keep first 3000 chars
+                    const newsContent = scrapedContent.data?.substring(0, 3000) || '';
+                    combinedResults += newsContent + (scrapedContent.data && scrapedContent.data.length > 3000 ? '\n...(truncated)' : '');
+                }
+                else {
+                    combinedResults += `(News scrape failed: ${scrapedContent.error})`;
+                }
+            }
+            catch (scrapeError) {
+                combinedResults += `(News scrape failed: ${scrapeError instanceof Error ? scrapeError.message : String(scrapeError)})`;
+            }
+            combinedResults += `\n--- END NEWS ---\n`;
         }
     }
     combinedResults += `\n--- END DATA ---\n\n`;
@@ -161,19 +182,16 @@ Market Intelligence, Referee stats, Weather, Fatigue analysis, Set Pieces.`, {
     }, async ({ homeTeam, awayTeam, league, context, useApi }) => {
         const errors = [];
         let analysisResult = null;
+        // Check API availability explicitly
+        const api = createAPIProvider();
+        const apiAvailable = api.getStatus().available;
+        const forcedFallback = useApi && !apiAvailable;
         // Try API providers first if requested
-        if (useApi) {
+        if (useApi && apiAvailable) {
             try {
-                const api = createAPIProvider();
-                const apiStatus = api.getStatus();
-                if (apiStatus.available) {
-                    // Could try to fetch match data from API here
-                    // For now, we'll use the search-based analysis as fallback
-                    analysisResult = await performMatchAnalysis(homeTeam, awayTeam, league, context);
-                }
-                else {
-                    errors.push('API providers not configured');
-                }
+                // Could try to fetch match data from API here
+                // For now, we'll use the search-based analysis as fallback
+                analysisResult = await performMatchAnalysis(homeTeam, awayTeam, league, context);
             }
             catch (error) {
                 errors.push(`API error: ${error instanceof Error ? error.message : String(error)}`);
@@ -183,6 +201,11 @@ Market Intelligence, Referee stats, Weather, Fatigue analysis, Set Pieces.`, {
         if (!analysisResult) {
             analysisResult = await performMatchAnalysis(homeTeam, awayTeam, league, context);
         }
+        // Add warning if running in forced fallback mode
+        if (forcedFallback && analysisResult) {
+            const warning = "⚠️ **WARNING: Fallback Mode Active**\nNo API keys configured. Using web search and scraping (accuracy may vary).\n\n";
+            analysisResult = warning + analysisResult;
+        }
         return {
             content: [{ type: 'text', text: analysisResult }],
         };

package/dist/tools/sports/tracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/sports/tracker.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { PredictionTracker } from './core/tracker.js';
+import * as fs from 'fs/promises';
+const TEST_LOG_FILE = 'test_betting_log.json';
+describe('ROI Tracker System', () => {
+    let tracker;
+    beforeEach(async () => {
+        // Use a test file instead of the real one
+        tracker = new PredictionTracker(TEST_LOG_FILE);
+        // Clear previous test data
+        try {
+            await fs.unlink(TEST_LOG_FILE);
+        }
+        catch { }
+    });
+    afterAll(async () => {
+        try {
+            await fs.unlink(TEST_LOG_FILE);
+        }
+        catch { }
+    });
+    it('should track a new prediction', async () => {
+        const bet = await tracker.track({
+            league: 'Premier League',
+            homeTeam: 'Arsenal',
+            awayTeam: 'Man City',
+            selection: 'Over 2.5 Goals',
+            odds: 1.85,
+            stake: 10,
+            confidence: 80,
+            analysis: 'High scoring teams',
+            date: new Date().toISOString()
+        });
+        expect(bet.id).toBeDefined();
+        expect(bet.status).toBe('pending');
+        expect(bet.profit).toBeUndefined();
+        const pending = await tracker.list('pending');
+        expect(pending.length).toBe(1);
+        expect(pending[0].id).toBe(bet.id);
+    });
+    it('should resolve a prediction and calculate profit correctly', async () => {
+        const bet = await tracker.track({
+            league: 'Premier League',
+            homeTeam: 'Liverpool',
+            awayTeam: 'Chelsea',
+            selection: 'Liverpool Win',
+            odds: 2.0,
+            stake: 50,
+            confidence: 90,
+            analysis: 'Form is good',
+            date: new Date().toISOString()
+        });
+        // Resolve as WON
+        const resolved = await tracker.resolve(bet.id, 'won', '2-0');
+        expect(resolved).toBeDefined();
+        expect(resolved.status).toBe('won');
+        expect(resolved.profit).toBe(50); // (50 * 2.0) - 50 = 50
+        expect(resolved.resultScore).toBe('2-0');
+        // Check Stats
+        const stats = await tracker.getStats();
+        expect(stats.totalBets).toBe(1);
+        expect(stats.wins).toBe(1);
+        expect(stats.totalProfit).toBe(50);
+        expect(stats.roi).toBe(100); // (50/50)*100
+    });
+    it('should handle lost bets correctly', async () => {
+        const bet = await tracker.track({
+            league: 'La Liga',
+            homeTeam: 'Real Madrid',
+            awayTeam: 'Barca',
+            selection: 'Real Win',
+            odds: 2.5,
+            stake: 100,
+            confidence: 60,
+            analysis: 'El Classico',
+            date: new Date().toISOString()
+        });
+        // Resolve as LOST
+        const resolved = await tracker.resolve(bet.id, 'lost', '0-3');
+        expect(resolved.status).toBe('lost');
+        expect(resolved.profit).toBe(-100);
+        const stats = await tracker.getStats();
+        expect(stats.totalProfit).toBe(-100);
+        expect(stats.roi).toBe(-100); // (-100/100)*100
+    });
+    it('should filter stats by league', async () => {
+        await tracker.track({
+            league: 'EPL', homeTeam: 'A', awayTeam: 'B', selection: 'Win', odds: 2.0, stake: 10, confidence: 50, analysis: '.', date: new Date().toISOString()
+        }).then(b => tracker.resolve(b.id, 'won')); // Profit +10
+        await tracker.track({
+            league: 'La Liga', homeTeam: 'C', awayTeam: 'D', selection: 'Win', odds: 2.0, stake: 10, confidence: 50, analysis: '.', date: new Date().toISOString()
+        }).then(b => tracker.resolve(b.id, 'lost')); // Profit -10
+        const eplStats = await tracker.getStats({ league: 'EPL' });
+        expect(eplStats.totalProfit).toBe(10);
+        const ligaStats = await tracker.getStats({ league: 'La Liga' });
+        expect(ligaStats.totalProfit).toBe(-10);
+        const allStats = await tracker.getStats();
+        expect(allStats.totalProfit).toBe(0);
+    });
+});

package/dist/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { validatePath } from './utils.js';
+import * as path from 'path';
+describe('Utils: validatePath', () => {
+    // Mock process.cwd to be a known fixed path
+    const mockCwd = '/app/project';
+    beforeEach(() => {
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should allow paths within the project root', () => {
+        const p = validatePath('src/index.ts');
+        expect(p).toBe(path.resolve(mockCwd, 'src/index.ts'));
+    });
+    it('should allow explicit ./ paths', () => {
+        const p = validatePath('./package.json');
+        expect(p).toBe(path.resolve(mockCwd, 'package.json'));
+    });
+    it('should block traversal to parent directory', () => {
+        expect(() => {
+            validatePath('../outside.txt');
+        }).toThrow(/Access denied/);
+    });
+    it('should block multiple level traversal', () => {
+        expect(() => {
+            validatePath('src/../../etc/passwd');
+        }).toThrow(/Access denied/);
+    });
+    it('should block absolute paths outside root', () => {
+        // Only run this check if we can reliably simulate absolute paths
+        // For now, let's assume standard unix paths for the test logic
+        if (path.sep === '/') {
+            expect(() => {
+                validatePath('/etc/passwd');
+            }).toThrow(/Access denied/);
+        }
+    });
+});

package/dist/verify_cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/verify_cache.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+describe('Graph Caching Verification', () => {
+    const root = process.cwd();
+    const cachePath = path.join(root, '.gemini_graph_cache.json');
+    beforeEach(async () => {
+        // Cleanup existing cache before each test
+        try {
+            await fs.unlink(cachePath);
+        }
+        catch (e) { }
+    });
+    it('should use cache on second run', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-cache-test-'));
+        const testFile = path.join(tempDir, 'main.ts');
+        try {
+            // Create a dummy file to scan
+            await fs.writeFile(testFile, 'export const val = 1;', 'utf-8');
+            console.log('--- Run 1 (Fresh) ---');
+            const res1 = await graph.build(tempDir);
+            console.log('Result 1:', res1);
+            expect(res1.parsedFiles).toBeGreaterThan(0);
+            expect(res1.cachedFiles).toBe(0);
+            console.log('--- Run 2 (Cached) ---');
+            const res2 = await graph.build(tempDir);
+            console.log('Result 2:', res2);
+            expect(res2.parsedFiles).toBe(0);
+            expect(res2.cachedFiles).toBeGreaterThan(0);
+            expect(res2.nodeCount).toBe(res1.nodeCount);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should invalidate cache when file mtime changes', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-mtime-test-'));
+        const testFile = path.join(tempDir, 'test.ts');
+        try {
+            // Create initial file
+            await fs.writeFile(testFile, 'export const foo = 1;', 'utf-8');
+            // Build 1: Fresh
+            const res1 = await graph.build(tempDir);
+            expect(res1.parsedFiles).toBe(1);
+            expect(res1.cachedFiles).toBe(0);
+            console.log('Build 1 (fresh):', res1);
+            // Build 2: Should use cache
+            const res2 = await graph.build(tempDir);
+            expect(res2.parsedFiles).toBe(0);
+            expect(res2.cachedFiles).toBe(1);
+            console.log('Build 2 (cached):', res2);
+            // Modify file content (this changes mtime)
+            await new Promise(resolve => setTimeout(resolve, 50)); // Small delay to ensure mtime changes
+            await fs.writeFile(testFile, 'export const bar = 2;', 'utf-8');
+            // Build 3: Should detect mtime change and re-parse
+            const res3 = await graph.build(tempDir);
+            expect(res3.parsedFiles).toBe(1); // File should be re-parsed due to mtime change
+            expect(res3.cachedFiles).toBe(0);
+            console.log('Build 3 (mtime changed):', res3);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should detect new files added after cache was built', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-newfile-test-'));
+        const file1 = path.join(tempDir, 'a.ts');
+        const file2 = path.join(tempDir, 'b.ts');
+        try {
+            // Create initial file
+            await fs.writeFile(file1, 'export const a = 1;', 'utf-8');
+            // Build 1: Only one file
+            const res1 = await graph.build(tempDir);
+            expect(res1.nodeCount).toBe(1);
+            expect(res1.totalFiles).toBe(1);
+            console.log('Build 1 (1 file):', res1);
+            // Add new file
+            await fs.writeFile(file2, 'export const b = 2;', 'utf-8');
+            // Build 2: Should detect new file
+            const res2 = await graph.build(tempDir);
+            expect(res2.nodeCount).toBe(2);
+            expect(res2.totalFiles).toBe(2);
+            expect(res2.parsedFiles).toBe(1); // Only the new file should be parsed
+            expect(res2.cachedFiles).toBe(1); // Old file should use cache
+            console.log('Build 2 (new file added):', res2);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should handle deleted files by pruning from cache', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-delete-test-'));
+        const file1 = path.join(tempDir, 'keep.ts');
+        const file2 = path.join(tempDir, 'delete.ts');
+        try {
+            // Create two files
+            await fs.writeFile(file1, 'export const keep = 1;', 'utf-8');
+            await fs.writeFile(file2, 'export const deleted = 2;', 'utf-8');
+            // Build 1: Two files
+            const res1 = await graph.build(tempDir);
+            expect(res1.nodeCount).toBe(2);
+            console.log('Build 1 (2 files):', res1);
+            // Delete one file
+            await fs.unlink(file2);
+            // Build 2: Should only have one file, cache pruned
+            const res2 = await graph.build(tempDir);
+            expect(res2.nodeCount).toBe(1);
+            expect(res2.totalFiles).toBe(1);
+            console.log('Build 2 (after delete):', res2);
+            // Verify cache file doesn't have deleted file
+            const cacheContent = JSON.parse(await fs.readFile(path.join(tempDir, '.gemini_graph_cache.json'), 'utf-8'));
+            expect(cacheContent.files[file2]).toBeUndefined();
+            expect(cacheContent.files[file1]).toBeDefined();
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should force rebuild when forceRebuild() is called', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-force-test-'));
+        const testFile = path.join(tempDir, 'test.ts');
+        try {
+            // Create file
+            await fs.writeFile(testFile, 'export const x = 1;', 'utf-8');
+            // Build 1: Fresh
+            const res1 = await graph.build(tempDir);
+            expect(res1.parsedFiles).toBe(1);
+            console.log('Build 1 (fresh):', res1);
+            // Build 2: Should use cache
+            const res2 = await graph.build(tempDir);
+            expect(res2.parsedFiles).toBe(0);
+            expect(res2.cachedFiles).toBe(1);
+            console.log('Build 2 (cached):', res2);
+            // Force rebuild: Should ignore cache
+            const res3 = await graph.forceRebuild(tempDir);
+            expect(res3.parsedFiles).toBe(1); // Force re-parse everything
+            expect(res3.cachedFiles).toBe(0);
+            console.log('Build 3 (force):', res3);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should have consistent results between cached and fresh builds', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-consistent-test-'));
+        const file1 = path.join(tempDir, 'main.ts');
+        const file2 = path.join(tempDir, 'utils.ts');
+        try {
+            // Create files with imports
+            await fs.writeFile(file2, 'export function helper() { return 42; }', 'utf-8');
+            await fs.writeFile(file1, 'import { helper } from "./utils.js";\nexport const result = helper();', 'utf-8');
+            // Build 1: Fresh
+            const res1 = await graph.build(tempDir);
+            const rel1 = graph.getRelationships('main.ts');
+            // Build 2: Cached
+            const res2 = await graph.build(tempDir);
+            const rel2 = graph.getRelationships('main.ts');
+            // Force rebuild: Fresh again
+            const res3 = await graph.forceRebuild(tempDir);
+            const rel3 = graph.getRelationships('main.ts');
+            // All should have same relationships
+            expect(rel1).toEqual(rel2);
+            expect(rel2).toEqual(rel3);
+            expect(rel1?.imports.length).toBeGreaterThan(0);
+            console.log('Relationships consistent:', JSON.stringify(rel1, null, 2));
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/web_fallback.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/web_fallback.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { registerWebTools } from './tools/web.js';
+import * as utils from './utils.js';
+// Mock utils
+vi.mock('./utils.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        fetchWithRetry: vi.fn(),
+    };
+});
+describe('web_search fallback', () => {
+    let mockToolCallback;
+    const mockServer = {
+        tool: vi.fn((name, desc, schema, callback) => {
+            if (name === 'web_search') {
+                mockToolCallback = callback;
+            }
+        })
+    };
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it('should use Brave if configured and no provider specified', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        delete process.env.EXA_API_KEY;
+        delete process.env.GOOGLE_SEARCH_API_KEY;
+        registerWebTools(mockServer);
+        const mockResponse = {
+            ok: true,
+            json: async () => ({ web: { results: ['brave result'] } })
+        };
+        utils.fetchWithRetry.mockResolvedValue(mockResponse);
+        const result = await mockToolCallback({ query: 'test' });
+        expect(utils.fetchWithRetry).toHaveBeenCalledWith(expect.stringContaining('api.search.brave.com'), expect.anything());
+        expect(result.isError).toBeUndefined();
+        expect(JSON.parse(result.content[0].text)).toEqual(['brave result']);
+    });
+    it('should fallback to Exa if Brave fails', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        process.env.EXA_API_KEY = 'test-exa-key';
+        registerWebTools(mockServer);
+        // First call (Brave) fails
+        utils.fetchWithRetry
+            .mockResolvedValueOnce({ ok: false, statusText: 'Brave Error', status: 500 })
+            // Second call (Exa) succeeds
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ results: ['exa result'] })
+        });
+        const result = await mockToolCallback({ query: 'test' });
+        expect(utils.fetchWithRetry).toHaveBeenCalledTimes(2);
+        // 1. Brave
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(1, expect.stringContaining('api.search.brave.com'), expect.anything());
+        // 2. Exa
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(2, expect.stringContaining('api.exa.ai'), expect.anything());
+        expect(result.isError).toBeUndefined();
+        expect(JSON.parse(result.content[0].text)).toEqual(['exa result']);
+    });
+    it('should respect requested provider and verify its availability', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        // Exa not configured
+        delete process.env.EXA_API_KEY;
+        registerWebTools(mockServer);
+        const result = await mockToolCallback({ query: 'test', provider: 'exa' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Requested provider 'exa' is not configured");
+    });
+    it('should try requested provider first, then fallback', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        process.env.EXA_API_KEY = 'test-exa-key';
+        registerWebTools(mockServer);
+        // Request Exa
+        // Mock Exa fail, Brave success
+        utils.fetchWithRetry
+            .mockResolvedValueOnce({ ok: false, statusText: 'Exa Error', status: 500 })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ web: { results: ['brave result'] } })
+        });
+        const result = await mockToolCallback({ query: 'test', provider: 'exa' });
+        expect(utils.fetchWithRetry).toHaveBeenCalledTimes(2);
+        // 1. Exa (requested)
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(1, expect.stringContaining('api.exa.ai'), expect.anything());
+        // 2. Brave (fallback)
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(2, expect.stringContaining('api.search.brave.com'), expect.anything());
+        expect(result.isError).toBeUndefined();
+    });
+    it('should return error if all fail', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        registerWebTools(mockServer);
+        utils.fetchWithRetry.mockResolvedValue({ ok: false, statusText: 'Some Error', status: 500 });
+        const result = await mockToolCallback({ query: 'test' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("All search providers failed");
+        expect(result.content[0].text).toContain("Brave API error");
+    });
+});

package/dist/web_read.test.d.ts

@@ -0,0 +1 @@
+export {};