@yasserkhanorg/impact-gate 2.0.0

package/dist/prompts/test-designer.js

@@ -0,0 +1,96 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTestDesignerPrompt = buildTestDesignerPrompt;
+exports.parseTestDesignerResponse = parseTestDesignerResponse;
+const json_extract_js_1 = require("./json_extract.js");
+const api_surface_js_1 = require("../knowledge/api_surface.js");
+const sanitize_js_1 = require("../crew/sanitize.js");
+function buildTestDesignerPrompt(ctx) {
+    const relevantClasses = ctx.apiSurface.pageObjects
+        .map((po) => po.className)
+        .filter((name) => {
+        const lower = name.toLowerCase();
+        const hints = [ctx.flow.routeFamily, ctx.flow.featureId, ...ctx.flow.userActions.join(' ').split(/\s+/)]
+            .filter(Boolean)
+            .map((s) => s.toLowerCase().replace(/[^a-z]/g, ''));
+        return lower.includes('page') || hints.some((h) => h.length > 3 && lower.includes(h));
+    })
+        .slice(0, 10);
+    const apiBlock = relevantClasses.length > 0
+        ? (0, api_surface_js_1.formatApiSurfaceForPrompt)(ctx.apiSurface, relevantClasses)
+        : 'No page objects available.';
+    const existingSpecsBlock = ctx.existingSpecs.length > 0
+        ? ctx.existingSpecs.map((s) => `- ${s.relativePath}: ${s.testTitles.join(', ')}`).join('\n')
+        : 'No existing specs.';
+    const crossImpactBlock = ctx.crossImpacts.length > 0
+        ? ctx.crossImpacts.map((ci) => `- ${ci.sourceFamily} → ${ci.affectedFamily}: ${ci.sharedDependency} (${ci.riskLevel})`).join('\n')
+        : 'None detected.';
+    const categories = ctx.strategy.testCategories.join(', ');
+    return [
+        `You are a senior QA engineer designing comprehensive test cases for a ${ctx.profile?.projectName || 'project'} user flow.`,
+        '',
+        `FLOW: ${ctx.flow.flowName}`,
+        `Flow ID: ${ctx.flow.flowId}`,
+        `Route Family: ${ctx.flow.routeFamily}${ctx.flow.featureId ? ` / ${ctx.flow.featureId}` : ''}`,
+        `Route: ${ctx.flow.specificRoute || '(not specified)'}`,
+        `Priority: ${ctx.strategy.priority}`,
+        `Approach: ${ctx.strategy.approach}`,
+        `User Actions: ${(0, sanitize_js_1.sanitizeForPrompt)(ctx.flow.userActions.join('; ') || 'unknown')}`,
+        `Evidence: ${(0, sanitize_js_1.sanitizeForPrompt)(ctx.flow.evidence)}`,
+        '',
+        `REQUIRED TEST CATEGORIES: ${categories}`,
+        '',
+        'AVAILABLE PAGE OBJECTS:',
+        apiBlock,
+        '',
+        'EXISTING SPECS (avoid duplicating these):',
+        existingSpecsBlock,
+        '',
+        'CROSS-FAMILY IMPACTS:',
+        crossImpactBlock,
+        '',
+        'TASK: Design structured test cases for this flow.',
+        '',
+        'Return strict JSON only with this shape:',
+        '{"testDesign":{"flowId":"<id>","flowName":"<name>","testCases":[{"name":"<descriptive name>","type":"<category>","preconditions":["<state required>"],"steps":["<user action>"],"expectedOutcome":"<what should happen>","priority":"P0|P1|P2","rationale":"<why this test matters>"}]}}',
+        '',
+        'TYPE VALUES: happy-path, edge-case, boundary, negative, state-transition, race-condition, permission, accessibility, performance',
+        '',
+        'Rules:',
+        '- Every test must describe a specific USER ACTION, not an implementation detail.',
+        '- Steps must be concrete: "click Create Channel button" not "test channel creation".',
+        '- Include preconditions (logged-in role, existing data state, etc.).',
+        '- Reference only page objects and methods listed above.',
+        '- Include a mandatory rationale explaining why this specific test case matters.',
+        '- Do NOT duplicate tests already covered by existing specs.',
+        '- Maximum 15 test cases per flow.',
+        '- For accessibility: test keyboard navigation, screen reader support, ARIA labels.',
+        '- For performance: test with realistic data volumes, measure load times.',
+        '- For edge cases: test unicode input, max-length fields, empty states, concurrent edits.',
+        '',
+        'FEW-SHOT EXAMPLES:',
+        '',
+        'Edge case example:',
+        '```json',
+        '{"name":"channel creation with unicode characters and max-length name","type":"edge-case","preconditions":["logged in as team member","team has < 1000 channels"],"steps":["open create channel dialog","enter 64-character name with emoji and CJK characters","click Create"],"expectedOutcome":"channel created successfully, name renders correctly in sidebar and header","priority":"P1","rationale":"catches encoding issues in channel name storage and rendering"}',
+        '```',
+        '',
+        'Permission example:',
+        '```json',
+        '{"name":"guest user cannot archive a public channel","type":"permission","preconditions":["logged in as guest user","guest has access to public channel"],"steps":["open channel header menu","look for Archive Channel option"],"expectedOutcome":"Archive Channel option is not visible in the menu","priority":"P0","rationale":"permission escalation bug — guests archiving channels could disrupt entire teams"}',
+        '```',
+        '',
+        'Accessibility example:',
+        '```json',
+        '{"name":"keyboard navigation through channel switcher results","type":"accessibility","preconditions":["logged in","channel switcher open via Ctrl+K"],"steps":["type partial channel name","press ArrowDown to navigate results","press Enter to select"],"expectedOutcome":"focus moves visually and via aria-activedescendant, selected channel opens","priority":"P1","rationale":"screen reader users rely on keyboard navigation — broken focus management makes the app unusable"}',
+        '```',
+    ].join('\n');
+}
+function parseTestDesignerResponse(text) {
+    return (0, json_extract_js_1.extractJsonFromResponse)(text, (obj) => {
+        const r = obj;
+        return r?.testDesign?.testCases != null && Array.isArray(r.testDesign.testCases);
+    });
+}

package/dist/provider_factory.d.ts

@@ -0,0 +1,104 @@
+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 an explicit preference when supplied, otherwise
+     * fall back to environment auto-detection.
+     */
+    static createFromPreference(providerPreference?: string): 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":"AAQA,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;IAyElD;;;OAGG;WACU,oBAAoB,CAAC,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IASpF;;;;;;;;;;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;AAoKD;;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,371 @@
+"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 logger_js_1 = require("./logger.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();
+        const normalizedProviderType = providerType?.trim().toLowerCase();
+        if (normalizedProviderType && !['ollama', 'openai', 'anthropic', 'auto'].includes(normalizedProviderType)) {
+            throw new Error(`Unknown LLM_PROVIDER value "${providerType}". Expected one of: ollama, openai, anthropic, auto`);
+        }
+        if (normalizedProviderType === '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 (normalizedProviderType === '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 (normalizedProviderType === '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) {
+            logger_js_1.logger.info('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 an explicit preference when supplied, otherwise
+     * fall back to environment auto-detection.
+     */
+    static async createFromPreference(providerPreference) {
+        const normalized = providerPreference?.trim().toLowerCase();
+        if (!normalized || normalized === 'auto') {
+            return this.createFromEnv();
+        }
+        return this.createFromString(normalized);
+    }
+    /**
+     * 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)
+        logger_js_1.logger.debug(`[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) {
+                logger_js_1.logger.debug(`[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) {
+            logger_js_1.logger.debug(`[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');
+        }
+        logger_js_1.logger.debug(`[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
+        const totalRequests = primaryStats.requestCount + fallbackStats.requestCount;
+        return {
+            requestCount: totalRequests,
+            totalInputTokens: primaryStats.totalInputTokens + fallbackStats.totalInputTokens,
+            totalOutputTokens: primaryStats.totalOutputTokens + fallbackStats.totalOutputTokens,
+            totalTokens: primaryStats.totalTokens + fallbackStats.totalTokens,
+            totalCost: primaryStats.totalCost + fallbackStats.totalCost,
+            averageResponseTimeMs: totalRequests > 0
+                ? (primaryStats.averageResponseTimeMs * primaryStats.requestCount +
+                    fallbackStats.averageResponseTimeMs * fallbackStats.requestCount) / totalRequests
+                : 0,
+            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();
+    }
+    async checkHealth() {
+        const primaryHealth = await this.primary.checkHealth();
+        if (primaryHealth.healthy) {
+            return { healthy: true, message: `${this.primary.name}: ${primaryHealth.message}` };
+        }
+        const fallbackHealth = await this.fallback.checkHealth();
+        if (fallbackHealth.healthy) {
+            return {
+                healthy: true,
+                message: `${this.primary.name} unhealthy (${primaryHealth.message}); fallback ${this.fallback.name}: ${fallbackHealth.message}`,
+            };
+        }
+        return {
+            healthy: false,
+            message: `${this.primary.name} unhealthy (${primaryHealth.message}); fallback ${this.fallback.name} unhealthy (${fallbackHealth.message})`,
+        };
+    }
+    /**
+     * 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,
+        };
+    }
+}