@yasserkhanorg/e2e-agents 0.3.2

package/dist/plan-and-test-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-and-test-constants.d.ts","sourceRoot":"","sources":["../src/plan-and-test-constants.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAsBlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;4CAOA,MAAM;;;sCAIZ,MAAM;qCACP,MAAM;4CACC,MAAM;;;uCAIX,MAAM;yCACJ,MAAM;;;4CAIH,MAAM;0CACR,MAAM;;;yCAIP,MAAM;8CACD,MAAM,QAAQ,MAAM;;;qCAI7B,MAAM,SAAS,MAAM;4CACd,MAAM;;;;;0CAMR,MAAM;0CACN,MAAM,SAAS,MAAM;0CACrB,MAAM;;;;;gDAWA,MAAM,EAAE;0CACd,MAAM,OAAO,MAAM;mDACV,MAAM,OAAO,MAAM;;;CAGnD,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,eAAe;;;;CAIlB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOzD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAE7C"}

package/dist/plan-and-test-constants.js

@@ -0,0 +1,132 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLOW_GROUP_TYPES = exports.TEST_STRATEGIES = exports.PRIORITY_LEVELS = exports.PLAN_AND_TEST_MESSAGES = exports.PLANNING_CONFIG = void 0;
+exports.getScenarioCount = getScenarioCount;
+exports.isValidPriority = isValidPriority;
+exports.getValidPriorities = getValidPriorities;
+/**
+ * Centralized constants for plan-and-test command
+ * Eliminates magic strings and hardcoded values
+ * Makes configuration easy to modify and maintain
+ */
+exports.PLANNING_CONFIG = {
+    // Number of test scenarios per priority level
+    SCENARIO_COUNTS: {
+        P0: 3,
+        P1: 2,
+        P2: 1,
+    },
+    // Default parameter values
+    DEFAULTS: {
+        MAX_TESTS: 10,
+        COVERAGE_THRESHOLD: 50,
+        PRIORITY_FILTER: ['P0', 'P1'],
+    },
+    // Limit constraints
+    LIMITS: {
+        MIN_MAX_TESTS: 1,
+        MAX_MAX_TESTS: 100,
+        MIN_COVERAGE_THRESHOLD: 0,
+        MAX_COVERAGE_THRESHOLD: 100,
+    },
+};
+/**
+ * Display messages for plan-and-test command
+ */
+exports.PLAN_AND_TEST_MESSAGES = {
+    HEADER: {
+        MAIN: '🚀 Planning and Generating Tests',
+        STEP_1_ANALYSIS: '📊 Step 1: Analyzing Code Changes...',
+        STEP_2_PLANNING: '💡 Step 2: Planning Test Generation...',
+        STEP_3_GENERATION: '⚡ Step 3: Generating Tests...',
+        STEP_4_SUMMARY: '📈 Generation Summary',
+        FOUND_FLOW_GROUPS: (count) => `📦 Found ${count} flow groups (end-to-end journeys):`,
+    },
+    ANALYSIS: {
+        FOUND_FLOWS: (count) => `✓ Found ${count} affected flows`,
+        MORE_FLOWS: (count) => `  ... and ${count} more`,
+        FOUND_FLOW_GROUPS: (count) => `📦 Found ${count} flow groups (end-to-end journeys)`,
+    },
+    PLANNING: {
+        PLAN_CREATED: (count) => `✓ Plan created: ${count} flows to test`,
+        SKIPPING_COUNT: (count) => `⊘ Skipping ${count} flows:`,
+    },
+    SKIP_REASONS: {
+        MAX_LIMIT_REACHED: (limit) => `Max tests limit reached (${limit})`,
+        ALREADY_COVERED: (count) => `Already covered (${count} existing tests)`,
+    },
+    COVERAGE_REASONS: {
+        NO_COVERAGE: (priority) => `${priority} - no coverage`,
+        PARTIAL_COVERAGE: (priority, gaps) => `${priority} - partial coverage (${gaps} gaps)`,
+    },
+    EXECUTION: {
+        TEST_COUNT: (index, total) => `[${index}/${total}]`,
+        GENERATION_FAILED: (error) => `  ⚠️ Generation failed: ${error}`,
+        DRY_RUN_MODE: '📋 DRY RUN: Not executing. Run without --dry-run to generate tests.',
+    },
+    SUMMARY: {
+        SEPARATOR: '═'.repeat(50),
+        TOTAL_GENERATED: (count) => `Total Tests Generated: ${count}`,
+        SUCCESSFUL: (successful, total) => `Successful: ${successful}/${total}`,
+        TOTAL_SCENARIOS: (count) => `Total Scenarios: ${count}`,
+        COMPLETION: '✅ Execution complete!',
+    },
+    NEXT_STEPS: [
+        '  • Run tests: npx playwright test --grep @smoke',
+        '  • Re-run impact: npx e2e-ai-agents impact --path <app-root> --tests-root <tests-root>',
+        '  • Check coverage: npm run test:impact',
+    ],
+    ERRORS: {
+        INVALID_PRIORITY: (priorities) => `Invalid priority levels: ${priorities.join(', ')}`,
+        INVALID_MAX_TESTS: (min, max) => `maxTests must be between ${min} and ${max}`,
+        INVALID_COVERAGE_THRESHOLD: (min, max) => `coverageThreshold must be between ${min} and ${max}`,
+        NO_CHANGES_DETECTED: '✓ No significant changes detected',
+    },
+};
+/**
+ * Priority levels in the system
+ */
+exports.PRIORITY_LEVELS = {
+    CRITICAL: 'P0',
+    HIGH: 'P1',
+    MEDIUM: 'P2',
+};
+/**
+ * Test strategy types for flow groups
+ */
+exports.TEST_STRATEGIES = {
+    SEQUENTIAL: 'sequential',
+    PARALLEL: 'parallel',
+    MIXED: 'mixed',
+};
+/**
+ * Flow group types
+ */
+exports.FLOW_GROUP_TYPES = {
+    MESSAGING_LIFECYCLE: 'messaging-lifecycle',
+    CHANNEL_MANAGEMENT: 'channel-management',
+    MESSAGING_INTERACTIONS: 'messaging-interactions',
+};
+/**
+ * Utility function to get scenario count for a priority
+ * Provides type-safe access to scenario counts
+ */
+function getScenarioCount(priority) {
+    const normalizedPriority = priority.toUpperCase();
+    return (exports.PLANNING_CONFIG.SCENARIO_COUNTS[normalizedPriority] || exports.PLANNING_CONFIG.SCENARIO_COUNTS.P1);
+}
+/**
+ * Utility function to validate priority level
+ */
+function isValidPriority(priority) {
+    const validPriorities = Object.values(exports.PRIORITY_LEVELS);
+    return validPriorities.includes(priority.toUpperCase());
+}
+/**
+ * Utility function to get all valid priority levels
+ */
+function getValidPriorities() {
+    return Object.values(exports.PRIORITY_LEVELS);
+}

package/dist/provider_factory.d.ts

@@ -0,0 +1,99 @@
+import type { LLMProvider, ProviderConfig } from './provider_interface.js';
+/**
+ * LLM Provider Factory
+ *
+ * Creates and configures LLM providers based on configuration.
+ * Supports multiple strategies:
+ * - Single provider (Ollama, Anthropic, etc.)
+ * - Hybrid provider (free primary + premium fallback)
+ * - Auto-selection based on environment
+ *
+ * Usage:
+ *
+ * // Create single provider
+ * const provider = LLMProviderFactory.create({
+ *   type: 'ollama',
+ *   config: { model: 'deepseek-r1:7b' }
+ * });
+ *
+ * // Create hybrid provider
+ * const provider = LLMProviderFactory.createHybrid({
+ *   primary: { type: 'ollama', config: { model: 'deepseek-r1:7b' } },
+ *   fallback: { type: 'anthropic', config: { apiKey: '...' } },
+ *   useFallbackFor: ['vision']
+ * });
+ *
+ * // Auto-detect from environment
+ * const provider = LLMProviderFactory.createFromEnv();
+ */
+export declare class LLMProviderFactory {
+    /**
+     * Create a single LLM provider
+     */
+    static create(config: ProviderConfig): LLMProvider;
+    /**
+     * Create a hybrid provider (free primary + premium fallback)
+     *
+     * Use cases:
+     * - Most operations use free Ollama
+     * - Vision tasks fall back to Claude
+     * - Complex diagnosis falls back to Claude
+     *
+     * This gives best cost/quality balance:
+     * - ~$20/month instead of $80/month (75% cost reduction)
+     * - Still get premium quality for vision and complex tasks
+     */
+    static createHybrid(config: HybridConfig): LLMProvider;
+    /**
+     * Auto-detect provider from environment variables
+     *
+     * Priority:
+     * 1. LLM_PROVIDER env var (ollama, anthropic, openai)
+     * 2. ANTHROPIC_API_KEY exists → Anthropic
+     * 3. OPENAI_API_KEY exists → OpenAI
+     * 4. Ollama running locally → Ollama
+     * 5. Error (no provider available)
+     */
+    static createFromEnv(): Promise<LLMProvider>;
+    /**
+     * Create provider from simple string format
+     *
+     * Examples:
+     * - "ollama" → Ollama with defaults
+     * - "ollama:deepseek-r1:14b" → Ollama with specific model
+     * - "anthropic" → Anthropic with env API key
+     * - "anthropic:claude-opus-4-5" → Anthropic with specific model
+     * - "openai" → OpenAI with env API key
+     * - "openai:gpt-4" → OpenAI with specific model
+     */
+    static createFromString(providerString: string): LLMProvider;
+}
+/**
+ * Hybrid Provider Configuration
+ */
+export interface HybridConfig {
+    /**
+     * Primary provider (used for most operations)
+     * Typically a free provider like Ollama
+     */
+    primary: ProviderConfig;
+    /**
+     * Fallback provider (used for specific capabilities)
+     * Typically a premium provider like Anthropic
+     */
+    fallback: ProviderConfig;
+    /**
+     * When to use fallback provider
+     * Options: 'vision', 'complex-diagnosis', 'high-confidence-needed'
+     */
+    useFallbackFor?: Array<'vision' | 'complex-diagnosis' | 'high-confidence-needed'>;
+}
+/**
+ * Helper to validate provider setup
+ */
+export declare function validateProviderSetup(provider: LLMProvider): Promise<{
+    valid: boolean;
+    message: string;
+    capabilities: string[];
+}>;
+//# sourceMappingURL=provider_factory.d.ts.map

package/dist/provider_factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider_factory.d.ts","sourceRoot":"","sources":["../src/provider_factory.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAKR,WAAW,EAIX,cAAc,EAEjB,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,kBAAkB;IAC3B;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW;IAmBlD;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAWtD;;;;;;;;;OASG;WACU,aAAa,IAAI,OAAO,CAAC,WAAW,CAAC;IAqElD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;CAkC/D;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB;;;OAGG;IACH,OAAO,EAAE,cAAc,CAAC;IAExB;;;OAGG;IACH,QAAQ,EAAE,cAAc,CAAC;IAEzB;;;OAGG;IACH,cAAc,CAAC,EAAE,KAAK,CAAC,QAAQ,GAAG,mBAAmB,GAAG,wBAAwB,CAAC,CAAC;CACrF;AAqJD;;GAEG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC;IACxE,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC,CAsCD"}

package/dist/provider_factory.js

@@ -0,0 +1,341 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMProviderFactory = void 0;
+exports.validateProviderSetup = validateProviderSetup;
+const anthropic_provider_js_1 = require("./anthropic_provider.js");
+const custom_provider_js_1 = require("./custom_provider.js");
+const ollama_provider_js_1 = require("./ollama_provider.js");
+const openai_provider_js_1 = require("./openai_provider.js");
+const provider_interface_js_1 = require("./provider_interface.js");
+/**
+ * LLM Provider Factory
+ *
+ * Creates and configures LLM providers based on configuration.
+ * Supports multiple strategies:
+ * - Single provider (Ollama, Anthropic, etc.)
+ * - Hybrid provider (free primary + premium fallback)
+ * - Auto-selection based on environment
+ *
+ * Usage:
+ *
+ * // Create single provider
+ * const provider = LLMProviderFactory.create({
+ *   type: 'ollama',
+ *   config: { model: 'deepseek-r1:7b' }
+ * });
+ *
+ * // Create hybrid provider
+ * const provider = LLMProviderFactory.createHybrid({
+ *   primary: { type: 'ollama', config: { model: 'deepseek-r1:7b' } },
+ *   fallback: { type: 'anthropic', config: { apiKey: '...' } },
+ *   useFallbackFor: ['vision']
+ * });
+ *
+ * // Auto-detect from environment
+ * const provider = LLMProviderFactory.createFromEnv();
+ */
+class LLMProviderFactory {
+    /**
+     * Create a single LLM provider
+     */
+    static create(config) {
+        switch (config.type) {
+            case 'ollama':
+                return new ollama_provider_js_1.OllamaProvider(config.config);
+            case 'anthropic':
+                return new anthropic_provider_js_1.AnthropicProvider(config.config);
+            case 'openai':
+                return new openai_provider_js_1.OpenAIProvider(config.config);
+            case 'custom':
+                return new custom_provider_js_1.CustomProvider(config.config);
+            default:
+                throw new Error(`Unknown provider type: ${config.type}`);
+        }
+    }
+    /**
+     * Create a hybrid provider (free primary + premium fallback)
+     *
+     * Use cases:
+     * - Most operations use free Ollama
+     * - Vision tasks fall back to Claude
+     * - Complex diagnosis falls back to Claude
+     *
+     * This gives best cost/quality balance:
+     * - ~$20/month instead of $80/month (75% cost reduction)
+     * - Still get premium quality for vision and complex tasks
+     */
+    static createHybrid(config) {
+        const primary = this.create(config.primary);
+        const fallback = this.create(config.fallback);
+        return new HybridProvider({
+            primary,
+            fallback,
+            useFallbackFor: config.useFallbackFor || ['vision'],
+        });
+    }
+    /**
+     * Auto-detect provider from environment variables
+     *
+     * Priority:
+     * 1. LLM_PROVIDER env var (ollama, anthropic, openai)
+     * 2. ANTHROPIC_API_KEY exists → Anthropic
+     * 3. OPENAI_API_KEY exists → OpenAI
+     * 4. Ollama running locally → Ollama
+     * 5. Error (no provider available)
+     */
+    static async createFromEnv() {
+        const providerType = process.env.LLM_PROVIDER?.toLowerCase();
+        if (providerType === 'ollama') {
+            return new ollama_provider_js_1.OllamaProvider({
+                baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434/v1',
+                model: process.env.OLLAMA_MODEL || 'deepseek-r1:7b',
+            });
+        }
+        if (providerType === 'openai') {
+            if (!process.env.OPENAI_API_KEY) {
+                throw new Error('OPENAI_API_KEY environment variable is required for OpenAI provider');
+            }
+            return new openai_provider_js_1.OpenAIProvider({
+                apiKey: process.env.OPENAI_API_KEY,
+                model: process.env.OPENAI_MODEL || 'gpt-4',
+                baseUrl: process.env.OPENAI_BASE_URL,
+                organizationId: process.env.OPENAI_ORG_ID,
+            });
+        }
+        if (providerType === 'anthropic') {
+            if (!process.env.ANTHROPIC_API_KEY) {
+                throw new Error('ANTHROPIC_API_KEY environment variable is required for Anthropic provider');
+            }
+            return new anthropic_provider_js_1.AnthropicProvider({
+                apiKey: process.env.ANTHROPIC_API_KEY,
+                model: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-5-20250929',
+            });
+        }
+        if (process.env.ANTHROPIC_API_KEY) {
+            return new anthropic_provider_js_1.AnthropicProvider({
+                apiKey: process.env.ANTHROPIC_API_KEY,
+                model: process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-5-20250929',
+            });
+        }
+        if (process.env.OPENAI_API_KEY) {
+            return new openai_provider_js_1.OpenAIProvider({
+                apiKey: process.env.OPENAI_API_KEY,
+                model: process.env.OPENAI_MODEL || 'gpt-4',
+                baseUrl: process.env.OPENAI_BASE_URL,
+                organizationId: process.env.OPENAI_ORG_ID,
+            });
+        }
+        // Try Ollama as default
+        const ollama = new ollama_provider_js_1.OllamaProvider({});
+        const health = await ollama.checkHealth();
+        if (health.healthy) {
+            // eslint-disable-next-line no-console
+            console.log('Auto-detected Ollama provider (free, local)');
+            return ollama;
+        }
+        throw new Error('No LLM provider available. Please either:\n' +
+            '1. Install Ollama: curl -fsSL https://ollama.com/install.sh | sh\n' +
+            '2. Set ANTHROPIC_API_KEY environment variable\n' +
+            '3. Set OPENAI_API_KEY environment variable\n' +
+            '4. Set LLM_PROVIDER environment variable');
+    }
+    /**
+     * Create provider from simple string format
+     *
+     * Examples:
+     * - "ollama" → Ollama with defaults
+     * - "ollama:deepseek-r1:14b" → Ollama with specific model
+     * - "anthropic" → Anthropic with env API key
+     * - "anthropic:claude-opus-4-5" → Anthropic with specific model
+     * - "openai" → OpenAI with env API key
+     * - "openai:gpt-4" → OpenAI with specific model
+     */
+    static createFromString(providerString) {
+        const [type, ...modelParts] = providerString.split(':');
+        const model = modelParts.join(':');
+        switch (type.toLowerCase()) {
+            case 'ollama':
+                return new ollama_provider_js_1.OllamaProvider({
+                    model: model || 'deepseek-r1:7b',
+                });
+            case 'anthropic':
+                if (!process.env.ANTHROPIC_API_KEY) {
+                    throw new Error('ANTHROPIC_API_KEY environment variable is required');
+                }
+                return new anthropic_provider_js_1.AnthropicProvider({
+                    apiKey: process.env.ANTHROPIC_API_KEY,
+                    model: model || 'claude-sonnet-4-5-20250929',
+                });
+            case 'openai':
+                if (!process.env.OPENAI_API_KEY) {
+                    throw new Error('OPENAI_API_KEY environment variable is required');
+                }
+                return new openai_provider_js_1.OpenAIProvider({
+                    apiKey: process.env.OPENAI_API_KEY,
+                    model: model || 'gpt-4',
+                    baseUrl: process.env.OPENAI_BASE_URL,
+                    organizationId: process.env.OPENAI_ORG_ID,
+                });
+            default:
+                throw new Error(`Unknown provider type: ${type}`);
+        }
+    }
+}
+exports.LLMProviderFactory = LLMProviderFactory;
+/**
+ * Hybrid Provider - Mix free and premium providers
+ *
+ * Strategy:
+ * - Use free provider (Ollama) for most operations (~80% of requests)
+ * - Fall back to premium (Claude) only when needed (~20% of requests)
+ *
+ * Cost savings example:
+ * - Pure Claude: $80/month
+ * - Pure Ollama: $0/month but no vision
+ * - Hybrid: $20/month (75% cost reduction, keeps vision)
+ */
+class HybridProvider {
+    constructor(config) {
+        this.name = 'hybrid';
+        this.capabilities = {
+            // Report combined capabilities
+            vision: true, // Fallback provides vision
+            streaming: true, // Both support streaming
+            maxTokens: 0, // Will be set in constructor
+            costPer1MInputTokens: 0, // Variable cost
+            costPer1MOutputTokens: 0, // Variable cost
+            supportsTools: true,
+            supportsPromptCaching: false,
+            typicalResponseTimeMs: 0, // Variable
+        };
+        this.primary = config.primary;
+        this.fallback = config.fallback;
+        this.useFallbackFor = new Set(config.useFallbackFor);
+        // Set combined capabilities
+        this.capabilities.maxTokens = Math.max(this.primary.capabilities.maxTokens, this.fallback.capabilities.maxTokens);
+        this.capabilities.typicalResponseTimeMs = this.primary.capabilities.typicalResponseTimeMs;
+    }
+    async generateText(prompt, options) {
+        // Use primary for text generation (free)
+        // eslint-disable-next-line no-console
+        console.log(`[Hybrid] Using ${this.primary.name} for text generation`);
+        return await this.primary.generateText(prompt, options);
+    }
+    async analyzeImage(images, prompt, options) {
+        // Check if vision is a fallback trigger
+        if (this.useFallbackFor.has('vision')) {
+            // Use fallback if primary doesn't support vision
+            if (!this.primary.capabilities.vision) {
+                // eslint-disable-next-line no-console
+                console.log(`[Hybrid] Using ${this.fallback.name} for vision analysis (primary doesn't support vision)`);
+                if (!this.fallback.analyzeImage) {
+                    throw new provider_interface_js_1.UnsupportedCapabilityError(this.name, 'vision');
+                }
+                return await this.fallback.analyzeImage(images, prompt, options);
+            }
+        }
+        // Try primary first
+        if (this.primary.analyzeImage) {
+            // eslint-disable-next-line no-console
+            console.log(`[Hybrid] Using ${this.primary.name} for vision analysis`);
+            return await this.primary.analyzeImage(images, prompt, options);
+        }
+        throw new provider_interface_js_1.UnsupportedCapabilityError(this.name, 'vision');
+    }
+    async *streamText(prompt, options) {
+        // Use primary for streaming (free)
+        if (!this.primary.streamText) {
+            throw new provider_interface_js_1.UnsupportedCapabilityError(this.primary.name, 'streaming');
+        }
+        // eslint-disable-next-line no-console
+        console.log(`[Hybrid] Using ${this.primary.name} for streaming`);
+        yield* this.primary.streamText(prompt, options);
+    }
+    getUsageStats() {
+        const primaryStats = this.primary.getUsageStats();
+        const fallbackStats = this.fallback.getUsageStats();
+        // Combine stats
+        return {
+            requestCount: primaryStats.requestCount + fallbackStats.requestCount,
+            totalInputTokens: primaryStats.totalInputTokens + fallbackStats.totalInputTokens,
+            totalOutputTokens: primaryStats.totalOutputTokens + fallbackStats.totalOutputTokens,
+            totalTokens: primaryStats.totalTokens + fallbackStats.totalTokens,
+            totalCost: primaryStats.totalCost + fallbackStats.totalCost,
+            averageResponseTimeMs: (primaryStats.averageResponseTimeMs * primaryStats.requestCount +
+                fallbackStats.averageResponseTimeMs * fallbackStats.requestCount) /
+                (primaryStats.requestCount + fallbackStats.requestCount),
+            failedRequests: primaryStats.failedRequests + fallbackStats.failedRequests,
+            startTime: new Date(Math.min(primaryStats.startTime.getTime(), fallbackStats.startTime.getTime())),
+            lastUpdated: new Date(Math.max(primaryStats.lastUpdated.getTime(), fallbackStats.lastUpdated.getTime())),
+        };
+    }
+    resetUsageStats() {
+        this.primary.resetUsageStats();
+        this.fallback.resetUsageStats();
+    }
+    /**
+     * Get breakdown of which provider was used for what
+     */
+    getProviderBreakdown() {
+        const primaryStats = this.primary.getUsageStats();
+        const fallbackStats = this.fallback.getUsageStats();
+        // Calculate what it would cost if we used only fallback
+        const totalRequests = primaryStats.requestCount + fallbackStats.requestCount;
+        const fallbackCostPerRequest = fallbackStats.requestCount > 0 ? fallbackStats.totalCost / fallbackStats.requestCount : 0;
+        const hypotheticalFullCost = totalRequests * fallbackCostPerRequest;
+        const actualCost = primaryStats.totalCost + fallbackStats.totalCost;
+        const savings = hypotheticalFullCost - actualCost;
+        const savingsPercent = hypotheticalFullCost > 0 ? (savings / hypotheticalFullCost) * 100 : 0;
+        return {
+            primary: {
+                name: this.primary.name,
+                stats: primaryStats,
+            },
+            fallback: {
+                name: this.fallback.name,
+                stats: fallbackStats,
+            },
+            costSavings: `$${savings.toFixed(2)} saved (${savingsPercent.toFixed(1)}% reduction)`,
+        };
+    }
+}
+/**
+ * Helper to validate provider setup
+ */
+async function validateProviderSetup(provider) {
+    const capabilities = [];
+    if (provider.capabilities.vision) {
+        capabilities.push('✓ Vision support (screenshot comparison)');
+    }
+    else {
+        capabilities.push('✗ No vision support');
+    }
+    if (provider.capabilities.streaming) {
+        capabilities.push('✓ Streaming responses');
+    }
+    if (provider.capabilities.supportsTools) {
+        capabilities.push('✓ Function calling');
+    }
+    capabilities.push(`✓ ${provider.capabilities.maxTokens.toLocaleString()} token context window`);
+    capabilities.push(`✓ Cost: $${provider.capabilities.costPer1MOutputTokens}/1M tokens`);
+    try {
+        // Try a simple request
+        const response = await provider.generateText('Say "OK" if you can read this', {
+            maxTokens: 10,
+        });
+        return {
+            valid: response.text.length > 0,
+            message: `Provider '${provider.name}' is working correctly`,
+            capabilities,
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            message: `Provider '${provider.name}' validation failed: ${error instanceof Error ? error.message : String(error)}`,
+            capabilities,
+        };
+    }
+}