@yasserkhanorg/e2e-agents 0.3.2

package/dist/anthropic_provider.js

@@ -0,0 +1,332 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+exports.checkAnthropicSetup = checkAnthropicSetup;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const provider_interface_js_1 = require("./provider_interface.js");
+const provider_utils_js_1 = require("./provider_utils.js");
+const base_provider_js_1 = require("./base_provider.js");
+const logger_js_1 = require("./logger.js");
+/**
+ * Anthropic Provider - Claude AI models
+ *
+ * Features:
+ * - Highest quality AI (98% accuracy in testing)
+ * - Vision support (analyze screenshots, compare UI)
+ * - Fast response times (<1 second)
+ * - 200K token context window
+ * - Prompt caching (reduces costs by 90% on repeated prompts)
+ *
+ * Costs (Claude Sonnet 4.5):
+ * - Input: $3 per 1M tokens
+ * - Output: $15 per 1M tokens
+ * - Cached input: $0.30 per 1M tokens
+ * - Estimated: ~$30-80/month for autonomous testing
+ *
+ * Use cases:
+ * - Vision tasks (screenshot comparison)
+ * - Complex failure diagnosis
+ * - High-stakes production testing
+ * - When quality is paramount
+ *
+ * Models:
+ * - claude-sonnet-4-5-20250929 (recommended - best balance)
+ * - claude-opus-4-5-20251101 (highest quality, slower, more expensive)
+ * - claude-haiku-4-0-20250430 (fastest, cheapest, lower quality)
+ */
+class AnthropicProvider extends base_provider_js_1.BaseProvider {
+    constructor(config) {
+        super();
+        this.name = 'anthropic';
+        this.capabilities = {
+            vision: true, // Full vision support
+            streaming: true,
+            maxTokens: 200000, // 200K context window
+            costPer1MInputTokens: 3, // $3 per 1M input tokens
+            costPer1MOutputTokens: 15, // $15 per 1M output tokens
+            supportsTools: true, // Function calling support
+            supportsPromptCaching: true, // Reduces costs by 90%
+            typicalResponseTimeMs: 800, // ~0.8 seconds
+        };
+        // SECURITY: Validate API key format
+        if (!provider_utils_js_1.API_KEY_PATTERNS.anthropic.test(config.apiKey)) {
+            throw new Error('Invalid API key format. Expected sk-ant-* format.');
+        }
+        // SECURITY: Validate and enforce HTTPS for remote connections
+        if (config.baseUrl) {
+            const validation = (0, provider_utils_js_1.validateAndSanitizeUrl)(config.baseUrl);
+            if (!validation.valid) {
+                throw new Error(`Invalid base URL: ${validation.warning}`);
+            }
+            if (validation.warning) {
+                logger_js_1.logger.warn(`HTTPS required for remote URLs: ${validation.warning}`);
+            }
+        }
+        this.client = new sdk_1.default({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+        });
+        this.model = config.model || 'claude-sonnet-4-5-20250929';
+    }
+    async generateText(prompt, options) {
+        const startTime = Date.now();
+        try {
+            // SECURITY: Validate prompt length to prevent resource exhaustion
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const response = await (0, provider_utils_js_1.withTimeout)(this.client.messages.create({
+                model: this.model,
+                max_tokens: options?.maxTokens || 4000,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop_sequences: options?.stopSequences,
+                system: options?.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+            }), options?.timeout, 'generateText');
+            const responseTime = Date.now() - startTime;
+            const text = this.extractTextFromResponse(response);
+            // SECURITY: Type-safe usage extraction
+            const usage = this.extractUsageFromResponse(response.usage);
+            const cost = this.calculateCost(usage, this.capabilities.costPer1MInputTokens, this.capabilities.costPer1MOutputTokens);
+            // Update stats
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    stopReason: response.stop_reason,
+                    stopSequence: response.stop_sequence,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'generateText'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    async analyzeImage(images, prompt, options) {
+        const startTime = Date.now();
+        try {
+            // SECURITY: Validate image array size
+            if (images.length === 0 || images.length > 20) {
+                throw new Error('Image count must be between 1 and 20');
+            }
+            // SECURITY: Validate prompt length
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            // Build content array with text and images
+            const content = [];
+            // Add prompt text first
+            content.push({
+                type: 'text',
+                text: prompt,
+            });
+            // Add each image
+            for (const image of images) {
+                // Validate media type
+                const mediaType = (image.mimeType || image.mediaType || 'image/png');
+                if (!['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(mediaType)) {
+                    throw new Error(`Unsupported image type: ${mediaType}`);
+                }
+                const data = image.data || image.base64 || '';
+                // SECURITY: Validate base64 data size (limit to 20MB per image)
+                if (data.length > 20 * 1024 * 1024) {
+                    throw new Error('Image data exceeds maximum size (20MB)');
+                }
+                content.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: mediaType,
+                        data: data,
+                    },
+                });
+                // Add description if provided
+                if (image.description) {
+                    content.push({
+                        type: 'text',
+                        text: `[Image: ${image.description}]`,
+                    });
+                }
+            }
+            const response = await (0, provider_utils_js_1.withTimeout)(this.client.messages.create({
+                model: this.model,
+                max_tokens: options?.maxTokens || 4000,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop_sequences: options?.stopSequences,
+                system: options?.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content,
+                    },
+                ],
+            }), options?.timeout, 'analyzeImage');
+            const responseTime = Date.now() - startTime;
+            const text = this.extractTextFromResponse(response);
+            // SECURITY: Type-safe usage extraction
+            const usage = this.extractUsageFromResponse(response.usage);
+            const cost = this.calculateCost(usage, this.capabilities.costPer1MInputTokens, this.capabilities.costPer1MOutputTokens);
+            // Update stats
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: {
+                    model: this.model,
+                    responseTimeMs: responseTime,
+                    stopReason: response.stop_reason,
+                    imageCount: images.length,
+                },
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'analyzeImage'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    async *streamText(prompt, options) {
+        try {
+            // SECURITY: Validate prompt length
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const stream = await (0, provider_utils_js_1.withTimeout)(this.client.messages.create({
+                model: this.model,
+                max_tokens: options?.maxTokens || 4000,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stop_sequences: options?.stopSequences,
+                system: options?.systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+                stream: true,
+            }), options?.timeout, 'streamText');
+            for await (const event of stream) {
+                if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+                    yield event.delta.text;
+                }
+            }
+            // Note: Streaming doesn't provide detailed usage stats
+            // We increment request count but can't track exact tokens/cost
+            this.stats.requestCount++;
+            this.stats.lastUpdated = new Date();
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'streamText'), this.name, this.extractStatusCode(error), error);
+        }
+    }
+    extractTextFromResponse(response) {
+        const textBlocks = response.content.filter((block) => block.type === 'text');
+        return textBlocks.map((block) => {
+            if (block.type === 'text') {
+                return block.text;
+            }
+            return '';
+        }).join('\n');
+    }
+    /**
+     * SECURITY: Type-safe usage extraction
+     * Avoids unsafe `as any` casts
+     */
+    extractUsageFromResponse(usage) {
+        return {
+            inputTokens: usage.input_tokens || 0,
+            outputTokens: usage.output_tokens || 0,
+            totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+            cachedTokens: usage.cache_read_input_tokens ?? undefined,
+        };
+    }
+    /**
+     * SECURITY: Extract status code safely
+     */
+    extractStatusCode(error) {
+        if (error && typeof error === 'object') {
+            const err = error;
+            const status = err.status;
+            if (typeof status === 'number') {
+                return status;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Check if API key is valid and service is accessible
+     */
+    async checkHealth() {
+        try {
+            // Try a minimal request to verify API key
+            await (0, provider_utils_js_1.withTimeout)(this.client.messages.create({
+                model: this.model,
+                max_tokens: 10,
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'Hi',
+                    },
+                ],
+            }), 5000, 'health check');
+            return {
+                healthy: true,
+                message: `Anthropic API is accessible`,
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                message: `Anthropic API error: ${(0, provider_utils_js_1.sanitizeErrorMessage)(error, 'health check')}`,
+            };
+        }
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;
+/**
+ * Helper to check Anthropic setup
+ */
+async function checkAnthropicSetup(apiKey) {
+    if (!apiKey) {
+        return {
+            valid: false,
+            message: 'No API key provided',
+            estimatedMonthlyCost: 'N/A',
+        };
+    }
+    try {
+        const provider = new AnthropicProvider({ apiKey });
+        const health = await provider.checkHealth();
+        return {
+            valid: health.healthy,
+            message: health.message,
+            estimatedMonthlyCost: '$30-80 for autonomous testing (24 cycles/day)',
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            message: `Setup check failed: ${(0, provider_utils_js_1.sanitizeErrorMessage)(error, 'setup check')}`,
+            estimatedMonthlyCost: 'N/A',
+        };
+    }
+}

package/dist/api.d.ts

@@ -0,0 +1,48 @@
+import { type ConfigOverrides } from './agent/config.js';
+import { type PlanReport } from './agent/plan.js';
+import type { ReportData } from './agent/report.js';
+import { type FinalizeGeneratedTestsOptions, type FinalizeGeneratedTestsResult } from './agent/handoff.js';
+import { type TraceabilityIngestOptions, type TraceabilityIngestResult } from './agent/traceability_ingest.js';
+import { type TraceabilityCaptureResult } from './agent/traceability_capture.js';
+export interface AgentApiOptions extends Omit<ConfigOverrides, 'mode'> {
+    cwd?: string;
+    configPath?: string;
+    apply?: boolean;
+    allowFallback?: boolean;
+}
+export interface AnalyzeResult {
+    report: ReportData;
+    reportPath: string;
+}
+export interface RecommendTestsResult extends AnalyzeResult {
+    plan: PlanReport;
+    planPath: string;
+    ciSummaryMarkdown: string;
+    ciSummaryPath: string;
+}
+export interface TraceabilityIngestApiOptions {
+    cwd?: string;
+    configPath?: string;
+    path?: string;
+    testsRoot?: string;
+    payload: unknown;
+    options?: TraceabilityIngestOptions;
+}
+export interface TraceabilityCaptureApiOptions {
+    cwd?: string;
+    configPath?: string;
+    path?: string;
+    testsRoot?: string;
+    reportPath: string;
+    sinceRef?: string;
+    outputPath?: string;
+    coverageMapPath?: string;
+    changedFilesPath?: string;
+}
+export declare function analyzeImpact(options?: AgentApiOptions): Promise<AnalyzeResult>;
+export declare function findGaps(options?: AgentApiOptions): Promise<AnalyzeResult>;
+export declare function recommendTests(options?: AgentApiOptions): Promise<RecommendTestsResult>;
+export declare function handoffGeneratedTests(options: FinalizeGeneratedTestsOptions): FinalizeGeneratedTestsResult;
+export declare function ingestTraceability(options: TraceabilityIngestApiOptions): TraceabilityIngestResult;
+export declare function captureTraceability(options: TraceabilityCaptureApiOptions): TraceabilityCaptureResult;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAEtE,OAAO,EAMH,KAAK,UAAU,EAClB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAyB,KAAK,6BAA6B,EAAE,KAAK,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AACjI,OAAO,EAEH,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAChC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAGH,KAAK,yBAAyB,EACjC,MAAM,iCAAiC,CAAC;AAEzC,MAAM,WAAW,eAAgB,SAAQ,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC;IAClE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,oBAAqB,SAAQ,aAAa;IACvD,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,4BAA4B;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,yBAAyB,CAAC;CACvC;AAED,MAAM,WAAW,6BAA6B;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AA0BD,wBAAsB,aAAa,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,aAAa,CAAC,CAOzF;AAED,wBAAsB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,aAAa,CAAC,CAOpF;AAED,wBAAsB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAwBjG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,6BAA6B,GAAG,4BAA4B,CAE1G;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,4BAA4B,GAAG,wBAAwB,CASlG;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,6BAA6B,GAAG,yBAAyB,CAkBrG"}

package/dist/api.js

@@ -0,0 +1,113 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImpact = analyzeImpact;
+exports.findGaps = findGaps;
+exports.recommendTests = recommendTests;
+exports.handoffGeneratedTests = handoffGeneratedTests;
+exports.ingestTraceability = ingestTraceability;
+exports.captureTraceability = captureTraceability;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_js_1 = require("./agent/config.js");
+const runner_js_1 = require("./agent/runner.js");
+const plan_js_1 = require("./agent/plan.js");
+const operational_insights_js_1 = require("./agent/operational_insights.js");
+const handoff_js_1 = require("./agent/handoff.js");
+const traceability_ingest_js_1 = require("./agent/traceability_ingest.js");
+const traceability_capture_js_1 = require("./agent/traceability_capture.js");
+function readReportJson(reportPath) {
+    if (!(0, fs_1.existsSync)(reportPath)) {
+        throw new Error(`Expected report not found: ${reportPath}`);
+    }
+    const raw = (0, fs_1.readFileSync)(reportPath, 'utf-8');
+    return JSON.parse(raw);
+}
+function resolveAgent(options, mode) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = (0, config_js_1.resolveConfig)(cwd, options.configPath, {
+        ...options,
+        mode,
+    });
+    if (options.allowFallback) {
+        config.impact.allowFallback = true;
+    }
+    return config;
+}
+function reportPathFor(configPath, mode) {
+    return (0, path_1.join)(configPath, '.e2e-ai-agents', mode === 'impact' ? 'impact.json' : 'gap.json');
+}
+async function analyzeImpact(options = {}) {
+    const config = resolveAgent(options, 'impact');
+    await (0, runner_js_1.runImpact)(config, { apply: options.apply ?? false });
+    const reportRoot = config.testsRoot || config.path;
+    const reportPath = reportPathFor(reportRoot, 'impact');
+    const report = readReportJson(reportPath);
+    return { report, reportPath };
+}
+async function findGaps(options = {}) {
+    const config = resolveAgent(options, 'gap');
+    await (0, runner_js_1.runGap)(config, { apply: options.apply ?? false });
+    const reportRoot = config.testsRoot || config.path;
+    const reportPath = reportPathFor(reportRoot, 'gap');
+    const report = readReportJson(reportPath);
+    return { report, reportPath };
+}
+async function recommendTests(options = {}) {
+    const config = resolveAgent(options, 'impact');
+    await (0, runner_js_1.runImpact)(config, { apply: options.apply ?? false });
+    const reportRoot = config.testsRoot || config.path;
+    const impactPath = reportPathFor(reportRoot, 'impact');
+    const report = readReportJson(impactPath);
+    const basePlan = (0, plan_js_1.buildPlanFromImpactReport)(report, config.policy);
+    const withActions = (0, plan_js_1.attachDeveloperActions)(basePlan, {
+        appPath: config.path,
+        testsRoot: reportRoot,
+        sinceRef: config.git.since,
+    });
+    const plan = (0, operational_insights_js_1.applyOperationalInsights)(withActions, reportRoot);
+    const planPath = (0, plan_js_1.writePlanReport)(reportRoot, plan);
+    const ciSummaryMarkdown = (0, plan_js_1.renderCiSummaryMarkdown)(plan);
+    const ciSummaryPath = (0, plan_js_1.writeCiSummary)(reportRoot, ciSummaryMarkdown);
+    return {
+        report,
+        reportPath: impactPath,
+        plan,
+        planPath,
+        ciSummaryMarkdown,
+        ciSummaryPath,
+    };
+}
+function handoffGeneratedTests(options) {
+    return (0, handoff_js_1.finalizeGeneratedTests)(options);
+}
+function ingestTraceability(options) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = (0, config_js_1.resolveConfig)(cwd, options.configPath, {
+        path: options.path,
+        testsRoot: options.testsRoot,
+        mode: 'impact',
+    });
+    const reportRoot = config.testsRoot || config.path;
+    return (0, traceability_ingest_js_1.ingestTraceabilityInput)(reportRoot, config.impact.traceability, options.payload, options.options);
+}
+function captureTraceability(options) {
+    const cwd = options.cwd || process.cwd();
+    const { config } = (0, config_js_1.resolveConfig)(cwd, options.configPath, {
+        path: options.path,
+        testsRoot: options.testsRoot,
+        mode: 'impact',
+    });
+    const reportRoot = config.testsRoot || config.path;
+    const captureOptions = {
+        appPath: config.path,
+        testsRoot: reportRoot,
+        reportPath: options.reportPath,
+        sinceRef: options.sinceRef || config.git.since,
+        outputPath: options.outputPath,
+        coverageMapPath: options.coverageMapPath,
+        changedFilesPath: options.changedFilesPath,
+    };
+    return (0, traceability_capture_js_1.captureTraceabilityInput)(captureOptions);
+}

package/dist/base_provider.d.ts

@@ -0,0 +1,53 @@
+import type { GenerateOptions, ImageInput, LLMProvider, LLMResponse, ProviderCapabilities, ProviderUsageStats } from './provider_interface.js';
+/**
+ * Abstract base class for all LLM providers
+ * Eliminates 240+ lines of duplicate stats management code
+ * Provides common functionality for token tracking, cost calculation, and stats management
+ */
+export declare abstract class BaseProvider implements LLMProvider {
+    abstract name: string;
+    abstract capabilities: ProviderCapabilities;
+    protected stats: ProviderUsageStats;
+    constructor();
+    /**
+     * Initialize stats object with default values
+     */
+    protected initializeStats(): void;
+    /**
+     * Update stats with new usage data
+     * Maintains rolling average for response time
+     */
+    protected updateStats(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    }, responseTime: number, cost: number): void;
+    /**
+     * Get a copy of current usage stats
+     */
+    getUsageStats(): ProviderUsageStats;
+    /**
+     * Reset all usage stats to initial state
+     */
+    resetUsageStats(): void;
+    /**
+     * Abstract methods that must be implemented by subclasses
+     */
+    abstract generateText(prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    abstract analyzeImage(images: ImageInput[], prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    abstract streamText(prompt: string, options?: GenerateOptions): AsyncGenerator<string, void, unknown>;
+    abstract checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+    /**
+     * Calculate cost for token usage, accounting for prompt caching discounts
+     * Cached tokens cost 90% less than regular tokens
+     */
+    protected calculateCost(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedTokens?: number;
+    }, costPer1MInputTokens: number, costPer1MOutputTokens: number): number;
+}
+//# sourceMappingURL=base_provider.d.ts.map

package/dist/base_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_provider.d.ts","sourceRoot":"","sources":["../src/base_provider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,eAAe,EACf,UAAU,EACV,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EACrB,MAAM,yBAAyB,CAAC;AAEjC;;;;GAIG;AACH,8BAAsB,YAAa,YAAW,WAAW;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAAC;IAE5C,SAAS,CAAC,KAAK,EAAG,kBAAkB,CAAC;;IAMrC;;OAEG;IACH,SAAS,CAAC,eAAe,IAAI,IAAI;IAcjC;;;OAGG;IACH,SAAS,CAAC,WAAW,CACjB,KAAK,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,EACvE,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,MAAM,GACb,IAAI;IAeP;;OAEG;IACH,aAAa,IAAI,kBAAkB;IAInC;;OAEG;IACH,eAAe,IAAI,IAAI;IAIvB;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IACtF,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAC5G,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IACrG,QAAQ,CAAC,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;IAEpE;;;OAGG;IACH,SAAS,CAAC,aAAa,CACnB,KAAK,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAC,EACzE,oBAAoB,EAAE,MAAM,EAC5B,qBAAqB,EAAE,MAAM,GAC9B,MAAM;CAmBZ"}

package/dist/base_provider.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = void 0;
+/**
+ * Abstract base class for all LLM providers
+ * Eliminates 240+ lines of duplicate stats management code
+ * Provides common functionality for token tracking, cost calculation, and stats management
+ */
+class BaseProvider {
+    constructor() {
+        this.initializeStats();
+    }
+    /**
+     * Initialize stats object with default values
+     */
+    initializeStats() {
+        this.stats = {
+            requestCount: 0,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            averageResponseTimeMs: 0,
+            failedRequests: 0,
+            startTime: new Date(),
+            lastUpdated: new Date(),
+        };
+    }
+    /**
+     * Update stats with new usage data
+     * Maintains rolling average for response time
+     */
+    updateStats(usage, responseTime, cost) {
+        this.stats.requestCount++;
+        this.stats.totalInputTokens += usage.inputTokens;
+        this.stats.totalOutputTokens += usage.outputTokens;
+        this.stats.totalTokens += usage.totalTokens;
+        this.stats.totalCost += cost;
+        // Update rolling average response time
+        const totalRequests = this.stats.requestCount;
+        this.stats.averageResponseTimeMs =
+            (this.stats.averageResponseTimeMs * (totalRequests - 1) + responseTime) / totalRequests;
+        this.stats.lastUpdated = new Date();
+    }
+    /**
+     * Get a copy of current usage stats
+     */
+    getUsageStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Reset all usage stats to initial state
+     */
+    resetUsageStats() {
+        this.initializeStats();
+    }
+    /**
+     * Calculate cost for token usage, accounting for prompt caching discounts
+     * Cached tokens cost 90% less than regular tokens
+     */
+    calculateCost(usage, costPer1MInputTokens, costPer1MOutputTokens) {
+        // Calculate input token cost
+        let inputCost = 0;
+        // Cached tokens cost 90% less
+        if (usage.cachedTokens) {
+            const cachedCost = (usage.cachedTokens / 1000000) * (costPer1MInputTokens * 0.1);
+            const uncachedInputTokens = usage.inputTokens - usage.cachedTokens;
+            const uncachedCost = (uncachedInputTokens / 1000000) * costPer1MInputTokens;
+            inputCost = cachedCost + uncachedCost;
+        }
+        else {
+            inputCost = (usage.inputTokens / 1000000) * costPer1MInputTokens;
+        }
+        // Calculate output token cost
+        const outputCost = (usage.outputTokens / 1000000) * costPer1MOutputTokens;
+        return inputCost + outputCost;
+    }
+}
+exports.BaseProvider = BaseProvider;

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}