@sparkleideas/providers 3.0.0-alpha.6-patch.26 → 3.0.0-alpha.6-patch.27

package/dist/base-provider.js

@@ -0,0 +1,636 @@
+"use strict";
+/**
+ * V3 Abstract Base Provider
+ *
+ * Provides common functionality for all LLM providers:
+ * - Circuit breaker protection
+ * - Health monitoring
+ * - Cost tracking
+ * - Request metrics
+ *
+ * @module @sparkleideas/providers/base-provider
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = exports.consoleLogger = void 0;
+var events_1 = require("events");
+var types_js_1 = require("./types.js");
+/**
+ * Simple circuit breaker implementation
+ */
+var CircuitBreaker = /** @class */ (function () {
+    function CircuitBreaker(name, threshold, resetTimeout) {
+        if (threshold === void 0) { threshold = 5; }
+        if (resetTimeout === void 0) { resetTimeout = 60000; }
+        this.name = name;
+        this.threshold = threshold;
+        this.resetTimeout = resetTimeout;
+        this.failures = 0;
+        this.lastFailure = 0;
+        this.state = 'closed';
+    }
+    CircuitBreaker.prototype.execute = function (fn) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.state === 'open') {
+                            if (Date.now() - this.lastFailure > this.resetTimeout) {
+                                this.state = 'half-open';
+                            }
+                            else {
+                                throw new Error("Circuit breaker ".concat(this.name, " is open"));
+                            }
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, fn()];
+                    case 2:
+                        result = _a.sent();
+                        this.onSuccess();
+                        return [2 /*return*/, result];
+                    case 3:
+                        error_1 = _a.sent();
+                        this.onFailure();
+                        throw error_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    CircuitBreaker.prototype.onSuccess = function () {
+        this.failures = 0;
+        this.state = 'closed';
+    };
+    CircuitBreaker.prototype.onFailure = function () {
+        this.failures++;
+        this.lastFailure = Date.now();
+        if (this.failures >= this.threshold) {
+            this.state = 'open';
+        }
+    };
+    CircuitBreaker.prototype.getState = function () {
+        return this.state;
+    };
+    return CircuitBreaker;
+}());
+/**
+ * Console logger implementation
+ */
+exports.consoleLogger = {
+    info: function (msg, meta) { return console.log("[INFO] ".concat(msg), meta || ''); },
+    warn: function (msg, meta) { return console.warn("[WARN] ".concat(msg), meta || ''); },
+    error: function (msg, err) { return console.error("[ERROR] ".concat(msg), err || ''); },
+    debug: function (msg, meta) { return console.debug("[DEBUG] ".concat(msg), meta || ''); },
+};
+/**
+ * Abstract base class for LLM providers
+ */
+var BaseProvider = /** @class */ (function (_super) {
+    __extends(BaseProvider, _super);
+    function BaseProvider(options) {
+        var _a, _b;
+        var _this = _super.call(this) || this;
+        // Metrics
+        _this.requestCount = 0;
+        _this.errorCount = 0;
+        _this.totalTokens = 0;
+        _this.totalCost = 0;
+        _this.requestMetrics = new Map();
+        _this.logger = options.logger || exports.consoleLogger;
+        _this.config = options.config;
+        // Initialize circuit breaker
+        _this.circuitBreaker = new CircuitBreaker("llm-".concat(_this.config.provider), ((_a = options.circuitBreakerOptions) === null || _a === void 0 ? void 0 : _a.threshold) || 5, ((_b = options.circuitBreakerOptions) === null || _b === void 0 ? void 0 : _b.resetTimeout) || 60000);
+        return _this;
+    }
+    /**
+     * Initialize the provider
+     */
+    BaseProvider.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.logger.info("Initializing ".concat(this.name, " provider"), {
+                            model: this.config.model,
+                            temperature: this.config.temperature,
+                            maxTokens: this.config.maxTokens,
+                        });
+                        // Validate configuration
+                        this.validateConfig();
+                        // Provider-specific initialization
+                        return [4 /*yield*/, this.doInitialize()];
+                    case 1:
+                        // Provider-specific initialization
+                        _a.sent();
+                        // Start health checks if caching enabled
+                        if (this.config.enableCaching) {
+                            this.startHealthChecks();
+                        }
+                        // Initial health check
+                        return [4 /*yield*/, this.healthCheck()];
+                    case 2:
+                        // Initial health check
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Validate provider configuration
+     */
+    BaseProvider.prototype.validateConfig = function () {
+        if (!this.config.model) {
+            throw new Error("Model is required for ".concat(this.name, " provider"));
+        }
+        if (!this.validateModel(this.config.model)) {
+            this.logger.warn("Model ".concat(this.config.model, " may not be supported by ").concat(this.name));
+        }
+        if (this.config.temperature !== undefined) {
+            if (this.config.temperature < 0 || this.config.temperature > 2) {
+                throw new Error('Temperature must be between 0 and 2');
+            }
+        }
+    };
+    /**
+     * Complete a request
+     */
+    BaseProvider.prototype.complete = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, response, latency, error_2, providerError;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        startTime = Date.now();
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.circuitBreaker.execute(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.doComplete(request)];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); })];
+                    case 2:
+                        response = _b.sent();
+                        latency = Date.now() - startTime;
+                        this.trackRequest(request, response, latency);
+                        this.emit('response', {
+                            provider: this.name,
+                            model: response.model,
+                            latency: latency,
+                            tokens: response.usage.totalTokens,
+                            cost: (_a = response.cost) === null || _a === void 0 ? void 0 : _a.totalCost,
+                        });
+                        return [2 /*return*/, response];
+                    case 3:
+                        error_2 = _b.sent();
+                        this.errorCount++;
+                        providerError = this.transformError(error_2);
+                        this.emit('error', {
+                            provider: this.name,
+                            error: providerError,
+                            request: request,
+                        });
+                        throw providerError;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stream complete a request
+     */
+    BaseProvider.prototype.streamComplete = function (request) {
+        return __asyncGenerator(this, arguments, function streamComplete_1() {
+            var startTime, totalTokens, totalCost, stream, _a, stream_1, stream_1_1, event_1, e_1_1, latency, error_3, providerError;
+            var _this = this;
+            var _b, e_1, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        startTime = Date.now();
+                        totalTokens = 0;
+                        totalCost = 0;
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 17, , 20]);
+                        if (!this.capabilities.supportsStreaming) {
+                            throw new types_js_1.LLMProviderError('Streaming not supported', 'STREAMING_NOT_SUPPORTED', this.name, undefined, false);
+                        }
+                        return [4 /*yield*/, __await(this.circuitBreaker.execute(function () { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    return [2 /*return*/, this.doStreamComplete(request)];
+                                });
+                            }); }))];
+                    case 2:
+                        stream = _e.sent();
+                        _e.label = 3;
+                    case 3:
+                        _e.trys.push([3, 10, 11, 16]);
+                        _a = true, stream_1 = __asyncValues(stream);
+                        _e.label = 4;
+                    case 4: return [4 /*yield*/, __await(stream_1.next())];
+                    case 5:
+                        if (!(stream_1_1 = _e.sent(), _b = stream_1_1.done, !_b)) return [3 /*break*/, 9];
+                        _d = stream_1_1.value;
+                        _a = false;
+                        event_1 = _d;
+                        if (event_1.usage) {
+                            totalTokens = event_1.usage.totalTokens;
+                        }
+                        if (event_1.cost) {
+                            totalCost = event_1.cost.totalCost;
+                        }
+                        return [4 /*yield*/, __await(event_1)];
+                    case 6: return [4 /*yield*/, _e.sent()];
+                    case 7:
+                        _e.sent();
+                        _e.label = 8;
+                    case 8:
+                        _a = true;
+                        return [3 /*break*/, 4];
+                    case 9: return [3 /*break*/, 16];
+                    case 10:
+                        e_1_1 = _e.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 16];
+                    case 11:
+                        _e.trys.push([11, , 14, 15]);
+                        if (!(!_a && !_b && (_c = stream_1.return))) return [3 /*break*/, 13];
+                        return [4 /*yield*/, __await(_c.call(stream_1))];
+                    case 12:
+                        _e.sent();
+                        _e.label = 13;
+                    case 13: return [3 /*break*/, 15];
+                    case 14:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 15: return [7 /*endfinally*/];
+                    case 16:
+                        latency = Date.now() - startTime;
+                        this.trackStreamRequest(request, totalTokens, totalCost, latency);
+                        return [3 /*break*/, 20];
+                    case 17:
+                        error_3 = _e.sent();
+                        this.errorCount++;
+                        providerError = this.transformError(error_3);
+                        return [4 /*yield*/, __await({ type: 'error', error: providerError })];
+                    case 18: return [4 /*yield*/, _e.sent()];
+                    case 19:
+                        _e.sent();
+                        throw providerError;
+                    case 20: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Validate if a model is supported
+     */
+    BaseProvider.prototype.validateModel = function (model) {
+        return this.capabilities.supportedModels.includes(model);
+    };
+    /**
+     * Perform health check
+     */
+    BaseProvider.prototype.healthCheck = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, result, error_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.doHealthCheck()];
+                    case 2:
+                        result = _a.sent();
+                        this.lastHealthCheck = __assign(__assign({}, result), { latency: Date.now() - startTime, timestamp: new Date() });
+                        this.emit('health_check', this.lastHealthCheck);
+                        return [2 /*return*/, this.lastHealthCheck];
+                    case 3:
+                        error_4 = _a.sent();
+                        this.lastHealthCheck = {
+                            healthy: false,
+                            error: error_4 instanceof Error ? error_4.message : 'Unknown error',
+                            latency: Date.now() - startTime,
+                            timestamp: new Date(),
+                        };
+                        this.emit('health_check', this.lastHealthCheck);
+                        return [2 /*return*/, this.lastHealthCheck];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Get provider status
+     */
+    BaseProvider.prototype.getStatus = function () {
+        var _a, _b;
+        var queueLength = this.requestMetrics.size;
+        return {
+            available: (_b = (_a = this.lastHealthCheck) === null || _a === void 0 ? void 0 : _a.healthy) !== null && _b !== void 0 ? _b : false,
+            currentLoad: Math.min(queueLength / 100, 1),
+            queueLength: queueLength,
+            activeRequests: queueLength,
+            rateLimitRemaining: this.getRateLimitRemaining(),
+            rateLimitReset: this.getRateLimitReset(),
+        };
+    };
+    /**
+     * Get remaining rate limit (override in provider)
+     */
+    BaseProvider.prototype.getRateLimitRemaining = function () {
+        return undefined;
+    };
+    /**
+     * Get rate limit reset time (override in provider)
+     */
+    BaseProvider.prototype.getRateLimitReset = function () {
+        return undefined;
+    };
+    /**
+     * Estimate cost for a request
+     */
+    BaseProvider.prototype.estimateCost = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var model, pricing, promptTokens, completionTokens, promptCost, completionCost;
+            var _a;
+            return __generator(this, function (_b) {
+                model = request.model || this.config.model;
+                pricing = (_a = this.capabilities.pricing) === null || _a === void 0 ? void 0 : _a[model];
+                if (!pricing) {
+                    return [2 /*return*/, {
+                            estimatedPromptTokens: 0,
+                            estimatedCompletionTokens: 0,
+                            estimatedTotalTokens: 0,
+                            estimatedCost: { prompt: 0, completion: 0, total: 0, currency: 'USD' },
+                            confidence: 0,
+                        }];
+                }
+                promptTokens = this.estimateTokens(JSON.stringify(request.messages));
+                completionTokens = request.maxTokens || this.config.maxTokens || 1000;
+                promptCost = (promptTokens / 1000) * pricing.promptCostPer1k;
+                completionCost = (completionTokens / 1000) * pricing.completionCostPer1k;
+                return [2 /*return*/, {
+                        estimatedPromptTokens: promptTokens,
+                        estimatedCompletionTokens: completionTokens,
+                        estimatedTotalTokens: promptTokens + completionTokens,
+                        estimatedCost: {
+                            prompt: promptCost,
+                            completion: completionCost,
+                            total: promptCost + completionCost,
+                            currency: pricing.currency,
+                        },
+                        confidence: 0.7,
+                    }];
+            });
+        });
+    };
+    /**
+     * Simple token estimation (4 chars ≈ 1 token)
+     */
+    BaseProvider.prototype.estimateTokens = function (text) {
+        return Math.ceil(text.length / 4);
+    };
+    /**
+     * Get usage statistics
+     */
+    BaseProvider.prototype.getUsage = function () {
+        return __awaiter(this, arguments, void 0, function (period) {
+            var now, start;
+            if (period === void 0) { period = 'day'; }
+            return __generator(this, function (_a) {
+                now = new Date();
+                start = this.getStartDate(now, period);
+                return [2 /*return*/, {
+                        period: { start: start, end: now },
+                        requests: this.requestCount,
+                        tokens: {
+                            prompt: Math.floor(this.totalTokens * 0.7),
+                            completion: Math.floor(this.totalTokens * 0.3),
+                            total: this.totalTokens,
+                        },
+                        cost: {
+                            prompt: this.totalCost * 0.7,
+                            completion: this.totalCost * 0.3,
+                            total: this.totalCost,
+                            currency: 'USD',
+                        },
+                        errors: this.errorCount,
+                        averageLatency: this.calculateAverageLatency(),
+                        modelBreakdown: {},
+                    }];
+            });
+        });
+    };
+    BaseProvider.prototype.getStartDate = function (end, period) {
+        var start = new Date(end);
+        switch (period) {
+            case 'hour':
+                start.setHours(start.getHours() - 1);
+                break;
+            case 'day':
+                start.setDate(start.getDate() - 1);
+                break;
+            case 'week':
+                start.setDate(start.getDate() - 7);
+                break;
+            case 'month':
+                start.setMonth(start.getMonth() - 1);
+                break;
+            case 'all':
+                start.setFullYear(2020);
+                break;
+        }
+        return start;
+    };
+    BaseProvider.prototype.calculateAverageLatency = function () {
+        if (this.requestMetrics.size === 0)
+            return 0;
+        var total = 0;
+        var count = 0;
+        this.requestMetrics.forEach(function (metrics) {
+            if (metrics.latency) {
+                total += metrics.latency;
+                count++;
+            }
+        });
+        return count > 0 ? total / count : 0;
+    };
+    /**
+     * Track successful request
+     */
+    BaseProvider.prototype.trackRequest = function (request, response, latency) {
+        var _a;
+        this.requestCount++;
+        this.totalTokens += response.usage.totalTokens;
+        if (response.cost) {
+            this.totalCost += response.cost.totalCost;
+        }
+        this.requestMetrics.set(response.id, {
+            timestamp: new Date(),
+            model: response.model,
+            tokens: response.usage.totalTokens,
+            cost: (_a = response.cost) === null || _a === void 0 ? void 0 : _a.totalCost,
+            latency: latency,
+        });
+        // Keep last 1000 metrics
+        if (this.requestMetrics.size > 1000) {
+            var oldestKey = this.requestMetrics.keys().next().value;
+            if (oldestKey)
+                this.requestMetrics.delete(oldestKey);
+        }
+    };
+    /**
+     * Track streaming request
+     */
+    BaseProvider.prototype.trackStreamRequest = function (request, totalTokens, totalCost, latency) {
+        this.requestCount++;
+        this.totalTokens += totalTokens;
+        this.totalCost += totalCost;
+        this.requestMetrics.set("stream-".concat(Date.now()), {
+            timestamp: new Date(),
+            model: request.model || this.config.model,
+            tokens: totalTokens,
+            cost: totalCost,
+            latency: latency,
+        });
+    };
+    /**
+     * Transform errors to provider errors
+     */
+    BaseProvider.prototype.transformError = function (error) {
+        if (error instanceof types_js_1.LLMProviderError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            if (error.message.includes('rate limit')) {
+                return new types_js_1.RateLimitError(error.message, this.name);
+            }
+            if (error.message.includes('timeout') || error.message.includes('ETIMEDOUT')) {
+                return new types_js_1.LLMProviderError('Request timed out', 'TIMEOUT', this.name, undefined, true);
+            }
+            if (error.message.includes('ECONNREFUSED') || error.message.includes('fetch failed')) {
+                return new types_js_1.ProviderUnavailableError(this.name, { originalError: error.message });
+            }
+        }
+        return new types_js_1.LLMProviderError(error instanceof Error ? error.message : String(error), 'UNKNOWN', this.name, undefined, true);
+    };
+    /**
+     * Start periodic health checks
+     */
+    BaseProvider.prototype.startHealthChecks = function () {
+        var _this = this;
+        var interval = this.config.cacheTimeout || 300000;
+        this.healthCheckInterval = setInterval(function () {
+            _this.healthCheck().catch(function (error) {
+                _this.logger.error("Health check failed for ".concat(_this.name), error);
+            });
+        }, interval);
+    };
+    /**
+     * Clean up resources
+     */
+    BaseProvider.prototype.destroy = function () {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+        }
+        this.requestMetrics.clear();
+        this.removeAllListeners();
+        this.logger.info("".concat(this.name, " provider destroyed"));
+    };
+    return BaseProvider;
+}(events_1.EventEmitter));
+exports.BaseProvider = BaseProvider;

package/dist/cohere-provider.d.ts

@@ -0,0 +1,26 @@
+/**
+ * V3 Cohere Provider
+ *
+ * Supports Command R+, Command R, and Command Light models.
+ *
+ * @module @sparkleideas/providers/cohere-provider
+ */
+import { BaseProvider, BaseProviderOptions } from './base-provider.js';
+import { LLMProvider, LLMModel, LLMRequest, LLMResponse, LLMStreamEvent, ModelInfo, ProviderCapabilities, HealthCheckResult } from './types.js';
+export declare class CohereProvider extends BaseProvider {
+    readonly name: LLMProvider;
+    readonly capabilities: ProviderCapabilities;
+    private baseUrl;
+    private headers;
+    constructor(options: BaseProviderOptions);
+    protected doInitialize(): Promise<void>;
+    protected doComplete(request: LLMRequest): Promise<LLMResponse>;
+    protected doStreamComplete(request: LLMRequest): AsyncIterable<LLMStreamEvent>;
+    listModels(): Promise<LLMModel[]>;
+    getModelInfo(model: LLMModel): Promise<ModelInfo>;
+    protected doHealthCheck(): Promise<HealthCheckResult>;
+    private buildRequest;
+    private transformResponse;
+    private handleErrorResponse;
+}
+//# sourceMappingURL=cohere-provider.d.ts.map

package/dist/cohere-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cohere-provider.d.ts","sourceRoot":"","sources":["../src/cohere-provider.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EACL,WAAW,EACX,QAAQ,EACR,UAAU,EACV,WAAW,EACX,cAAc,EACd,SAAS,EACT,oBAAoB,EACpB,iBAAiB,EAIlB,MAAM,YAAY,CAAC;AA0CpB,qBAAa,cAAe,SAAQ,YAAY;IAC9C,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAY;IACtC,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAsDzC;IAEF,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,OAAO,CAA8B;gBAEjC,OAAO,EAAE,mBAAmB;cAIxB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;cAY7B,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;cA4BpD,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,aAAa,CAAC,cAAc,CAAC;IAkF/E,UAAU,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAIjC,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;cAmBvC,aAAa,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAqB3D,OAAO,CAAC,YAAY;IA4DpB,OAAO,CAAC,iBAAiB;YAwCX,mBAAmB;CA4BlC"}