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

package/dist/provider-manager.js

@@ -0,0 +1,712 @@
+"use strict";
+/**
+ * V3 Provider Manager
+ *
+ * Orchestrates multiple LLM providers with:
+ * - Load balancing (round-robin, latency-based, cost-based)
+ * - Automatic failover
+ * - Request caching
+ * - Cost optimization
+ *
+ * @module @sparkleideas/providers/provider-manager
+ */
+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.ProviderManager = void 0;
+exports.createProviderManager = createProviderManager;
+var events_1 = require("events");
+var types_js_1 = require("./types.js");
+var base_provider_js_1 = require("./base-provider.js");
+var anthropic_provider_js_1 = require("./anthropic-provider.js");
+var openai_provider_js_1 = require("./openai-provider.js");
+var google_provider_js_1 = require("./google-provider.js");
+var cohere_provider_js_1 = require("./cohere-provider.js");
+var ollama_provider_js_1 = require("./ollama-provider.js");
+var ruvector_provider_js_1 = require("./ruvector-provider.js");
+/**
+ * Provider Manager - Orchestrates multiple LLM providers
+ */
+var ProviderManager = /** @class */ (function (_super) {
+    __extends(ProviderManager, _super);
+    function ProviderManager(config, logger) {
+        var _this = _super.call(this) || this;
+        _this.config = config;
+        _this.providers = new Map();
+        _this.cache = new Map();
+        _this.metrics = new Map();
+        _this.roundRobinIndex = 0;
+        _this.logger = logger || base_provider_js_1.consoleLogger;
+        return _this;
+    }
+    /**
+     * Initialize all configured providers
+     */
+    ProviderManager.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var initPromises;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.logger.info('Initializing provider manager', {
+                            providerCount: this.config.providers.length,
+                        });
+                        initPromises = this.config.providers.map(function (providerConfig) { return __awaiter(_this, void 0, void 0, function () {
+                            var provider, error_1;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        provider = this.createProvider(providerConfig);
+                                        return [4 /*yield*/, provider.initialize()];
+                                    case 1:
+                                        _a.sent();
+                                        this.providers.set(providerConfig.provider, provider);
+                                        this.metrics.set(providerConfig.provider, {
+                                            latency: 0,
+                                            errorRate: 0,
+                                            cost: 0,
+                                            lastUsed: 0,
+                                        });
+                                        this.logger.info("Provider ".concat(providerConfig.provider, " initialized"));
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        error_1 = _a.sent();
+                                        this.logger.error("Failed to initialize ".concat(providerConfig.provider), error_1);
+                                        return [3 /*break*/, 3];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        return [4 /*yield*/, Promise.all(initPromises)];
+                    case 1:
+                        _a.sent();
+                        this.logger.info('Provider manager initialized', {
+                            activeProviders: Array.from(this.providers.keys()),
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Create a provider instance
+     */
+    ProviderManager.prototype.createProvider = function (config) {
+        var options = {
+            config: config,
+            logger: this.logger,
+        };
+        switch (config.provider) {
+            case 'anthropic':
+                return new anthropic_provider_js_1.AnthropicProvider(options);
+            case 'openai':
+                return new openai_provider_js_1.OpenAIProvider(options);
+            case 'google':
+                return new google_provider_js_1.GoogleProvider(options);
+            case 'cohere':
+                return new cohere_provider_js_1.CohereProvider(options);
+            case 'ollama':
+                return new ollama_provider_js_1.OllamaProvider(options);
+            case 'ruvector':
+                return new ruvector_provider_js_1.RuVectorProvider(options);
+            default:
+                throw new Error("Unknown provider: ".concat(config.provider));
+        }
+    };
+    /**
+     * Complete a request with automatic provider selection
+     */
+    ProviderManager.prototype.complete = function (request, preferredProvider) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cached, provider, _a, startTime, response, error_2;
+            var _b, _c, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        // Check cache first
+                        if ((_b = this.config.cache) === null || _b === void 0 ? void 0 : _b.enabled) {
+                            cached = this.getCached(request);
+                            if (cached) {
+                                this.logger.debug('Cache hit', { requestId: request.requestId });
+                                return [2 /*return*/, cached];
+                            }
+                        }
+                        if (!preferredProvider) return [3 /*break*/, 1];
+                        _a = this.providers.get(preferredProvider);
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.selectProvider(request)];
+                    case 2:
+                        _a = _f.sent();
+                        _f.label = 3;
+                    case 3:
+                        provider = _a;
+                        if (!provider) {
+                            throw new Error('No available providers');
+                        }
+                        startTime = Date.now();
+                        _f.label = 4;
+                    case 4:
+                        _f.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, provider.complete(request)];
+                    case 5:
+                        response = _f.sent();
+                        this.updateMetrics(provider.name, Date.now() - startTime, false, ((_c = response.cost) === null || _c === void 0 ? void 0 : _c.totalCost) || 0);
+                        // Cache response
+                        if ((_d = this.config.cache) === null || _d === void 0 ? void 0 : _d.enabled) {
+                            this.setCached(request, response);
+                        }
+                        this.emit('complete', { provider: provider.name, response: response });
+                        return [2 /*return*/, response];
+                    case 6:
+                        error_2 = _f.sent();
+                        this.updateMetrics(provider.name, Date.now() - startTime, true, 0);
+                        // Try fallback
+                        if (((_e = this.config.fallback) === null || _e === void 0 ? void 0 : _e.enabled) && (0, types_js_1.isLLMProviderError)(error_2)) {
+                            return [2 /*return*/, this.completWithFallback(request, provider.name, error_2)];
+                        }
+                        throw error_2;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Stream complete with automatic provider selection
+     */
+    ProviderManager.prototype.streamComplete = function (request, preferredProvider) {
+        return __asyncGenerator(this, arguments, function streamComplete_1() {
+            var provider, _a, startTime, _b, _c, _d, event_1, e_1_1, error_3;
+            var _e, e_1, _f, _g;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        if (!preferredProvider) return [3 /*break*/, 1];
+                        _a = this.providers.get(preferredProvider);
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, __await(this.selectProvider(request))];
+                    case 2:
+                        _a = _h.sent();
+                        _h.label = 3;
+                    case 3:
+                        provider = _a;
+                        if (!provider) {
+                            throw new Error('No available providers');
+                        }
+                        startTime = Date.now();
+                        _h.label = 4;
+                    case 4:
+                        _h.trys.push([4, 19, , 20]);
+                        _h.label = 5;
+                    case 5:
+                        _h.trys.push([5, 12, 13, 18]);
+                        _b = true, _c = __asyncValues(provider.streamComplete(request));
+                        _h.label = 6;
+                    case 6: return [4 /*yield*/, __await(_c.next())];
+                    case 7:
+                        if (!(_d = _h.sent(), _e = _d.done, !_e)) return [3 /*break*/, 11];
+                        _g = _d.value;
+                        _b = false;
+                        event_1 = _g;
+                        return [4 /*yield*/, __await(event_1)];
+                    case 8: return [4 /*yield*/, _h.sent()];
+                    case 9:
+                        _h.sent();
+                        _h.label = 10;
+                    case 10:
+                        _b = true;
+                        return [3 /*break*/, 6];
+                    case 11: return [3 /*break*/, 18];
+                    case 12:
+                        e_1_1 = _h.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 18];
+                    case 13:
+                        _h.trys.push([13, , 16, 17]);
+                        if (!(!_b && !_e && (_f = _c.return))) return [3 /*break*/, 15];
+                        return [4 /*yield*/, __await(_f.call(_c))];
+                    case 14:
+                        _h.sent();
+                        _h.label = 15;
+                    case 15: return [3 /*break*/, 17];
+                    case 16:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 17: return [7 /*endfinally*/];
+                    case 18:
+                        this.updateMetrics(provider.name, Date.now() - startTime, false, 0);
+                        return [3 /*break*/, 20];
+                    case 19:
+                        error_3 = _h.sent();
+                        this.updateMetrics(provider.name, Date.now() - startTime, true, 0);
+                        throw error_3;
+                    case 20: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Select provider based on load balancing strategy
+     */
+    ProviderManager.prototype.selectProvider = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var availableProviders, strategy;
+            var _a;
+            return __generator(this, function (_b) {
+                availableProviders = Array.from(this.providers.values()).filter(function (p) { return p.getStatus().available; });
+                if (availableProviders.length === 0) {
+                    // Try to use any provider
+                    return [2 /*return*/, this.providers.values().next().value];
+                }
+                strategy = ((_a = this.config.loadBalancing) === null || _a === void 0 ? void 0 : _a.strategy) || 'round-robin';
+                switch (strategy) {
+                    case 'round-robin':
+                        return [2 /*return*/, this.selectRoundRobin(availableProviders)];
+                    case 'least-loaded':
+                        return [2 /*return*/, this.selectLeastLoaded(availableProviders)];
+                    case 'latency-based':
+                        return [2 /*return*/, this.selectByLatency(availableProviders)];
+                    case 'cost-based':
+                        return [2 /*return*/, this.selectByCost(availableProviders, request)];
+                    default:
+                        return [2 /*return*/, availableProviders[0]];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    ProviderManager.prototype.selectRoundRobin = function (providers) {
+        var provider = providers[this.roundRobinIndex % providers.length];
+        this.roundRobinIndex++;
+        return provider;
+    };
+    ProviderManager.prototype.selectLeastLoaded = function (providers) {
+        return providers.reduce(function (best, current) {
+            return current.getStatus().currentLoad < best.getStatus().currentLoad ? current : best;
+        });
+    };
+    ProviderManager.prototype.selectByLatency = function (providers) {
+        var _this = this;
+        return providers.reduce(function (best, current) {
+            var bestMetrics = _this.metrics.get(best.name);
+            var currentMetrics = _this.metrics.get(current.name);
+            return ((currentMetrics === null || currentMetrics === void 0 ? void 0 : currentMetrics.latency) || Infinity) < ((bestMetrics === null || bestMetrics === void 0 ? void 0 : bestMetrics.latency) || Infinity)
+                ? current
+                : best;
+        });
+    };
+    ProviderManager.prototype.selectByCost = function (providers, request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var estimates;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(providers.map(function (p) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = {
+                                            provider: p
+                                        };
+                                        return [4 /*yield*/, p.estimateCost(request)];
+                                    case 1: return [2 /*return*/, (_a.cost = (_b.sent()).estimatedCost.total,
+                                            _a)];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        estimates = _a.sent();
+                        return [2 /*return*/, estimates.reduce(function (best, current) {
+                                return current.cost < best.cost ? current : best;
+                            }).provider];
+                }
+            });
+        });
+    };
+    /**
+     * Complete with fallback on failure
+     */
+    ProviderManager.prototype.completWithFallback = function (request, failedProvider, originalError) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxAttempts, attempts, lastError, remainingProviders, _i, remainingProviders_1, provider, response, error_4;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        maxAttempts = ((_a = this.config.fallback) === null || _a === void 0 ? void 0 : _a.maxAttempts) || 2;
+                        attempts = 0;
+                        lastError = originalError;
+                        remainingProviders = Array.from(this.providers.values()).filter(function (p) { return p.name !== failedProvider; });
+                        _i = 0, remainingProviders_1 = remainingProviders;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < remainingProviders_1.length)) return [3 /*break*/, 6];
+                        provider = remainingProviders_1[_i];
+                        if (attempts >= maxAttempts)
+                            return [3 /*break*/, 6];
+                        attempts++;
+                        this.logger.info("Attempting fallback to ".concat(provider.name), {
+                            attempt: attempts,
+                            originalProvider: failedProvider,
+                        });
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, provider.complete(request)];
+                    case 3:
+                        response = _b.sent();
+                        this.emit('fallback_success', {
+                            originalProvider: failedProvider,
+                            fallbackProvider: provider.name,
+                            attempts: attempts,
+                        });
+                        return [2 /*return*/, response];
+                    case 4:
+                        error_4 = _b.sent();
+                        if ((0, types_js_1.isLLMProviderError)(error_4)) {
+                            lastError = error_4;
+                        }
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6:
+                        this.emit('fallback_exhausted', {
+                            originalProvider: failedProvider,
+                            attempts: attempts,
+                        });
+                        throw lastError;
+                }
+            });
+        });
+    };
+    /**
+     * Update provider metrics
+     */
+    ProviderManager.prototype.updateMetrics = function (provider, latency, error, cost) {
+        var current = this.metrics.get(provider) || {
+            latency: 0,
+            errorRate: 0,
+            cost: 0,
+            lastUsed: 0,
+        };
+        // Exponential moving average for latency
+        var alpha = 0.3;
+        var newLatency = current.latency === 0 ? latency : alpha * latency + (1 - alpha) * current.latency;
+        // Update error rate
+        var errorWeight = error ? 1 : 0;
+        var newErrorRate = alpha * errorWeight + (1 - alpha) * current.errorRate;
+        this.metrics.set(provider, {
+            latency: newLatency,
+            errorRate: newErrorRate,
+            cost: current.cost + cost,
+            lastUsed: Date.now(),
+        });
+    };
+    /**
+     * Get cached response
+     */
+    ProviderManager.prototype.getCached = function (request) {
+        var _a;
+        var key = this.getCacheKey(request);
+        var entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        var ttl = ((_a = this.config.cache) === null || _a === void 0 ? void 0 : _a.ttl) || 300000;
+        if (Date.now() - entry.timestamp > ttl) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        entry.hits++;
+        return entry.response;
+    };
+    /**
+     * Set cached response
+     */
+    ProviderManager.prototype.setCached = function (request, response) {
+        var _a;
+        var key = this.getCacheKey(request);
+        // Enforce max size
+        var maxSize = ((_a = this.config.cache) === null || _a === void 0 ? void 0 : _a.maxSize) || 1000;
+        if (this.cache.size >= maxSize) {
+            // Remove oldest entry
+            var oldest = Array.from(this.cache.entries()).sort(function (a, b) { return a[1].timestamp - b[1].timestamp; })[0];
+            if (oldest)
+                this.cache.delete(oldest[0]);
+        }
+        this.cache.set(key, {
+            response: response,
+            timestamp: Date.now(),
+            hits: 0,
+        });
+    };
+    /**
+     * Generate cache key
+     */
+    ProviderManager.prototype.getCacheKey = function (request) {
+        return JSON.stringify({
+            messages: request.messages,
+            model: request.model,
+            temperature: request.temperature,
+            maxTokens: request.maxTokens,
+        });
+    };
+    /**
+     * Get a specific provider
+     */
+    ProviderManager.prototype.getProvider = function (name) {
+        return this.providers.get(name);
+    };
+    /**
+     * List all available providers
+     */
+    ProviderManager.prototype.listProviders = function () {
+        return Array.from(this.providers.keys());
+    };
+    /**
+     * Health check all providers
+     */
+    ProviderManager.prototype.healthCheck = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var results;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        results = new Map();
+                        return [4 /*yield*/, Promise.all(Array.from(this.providers.entries()).map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                var result;
+                                var name = _b[0], provider = _b[1];
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4 /*yield*/, provider.healthCheck()];
+                                        case 1:
+                                            result = _c.sent();
+                                            results.set(name, result);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, results];
+                }
+            });
+        });
+    };
+    /**
+     * Estimate cost across providers
+     */
+    ProviderManager.prototype.estimateCost = function (request) {
+        return __awaiter(this, void 0, void 0, function () {
+            var estimates;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        estimates = new Map();
+                        return [4 /*yield*/, Promise.all(Array.from(this.providers.entries()).map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
+                                var estimate;
+                                var name = _b[0], provider = _b[1];
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4 /*yield*/, provider.estimateCost(request)];
+                                        case 1:
+                                            estimate = _c.sent();
+                                            estimates.set(name, estimate);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, estimates];
+                }
+            });
+        });
+    };
+    /**
+     * Get aggregated usage statistics
+     */
+    ProviderManager.prototype.getUsage = function () {
+        return __awaiter(this, arguments, void 0, function (period) {
+            var totalRequests, totalTokens, totalCost, totalErrors, totalLatency, count, _i, _a, provider, usage, now, start;
+            if (period === void 0) { period = 'day'; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        totalRequests = 0;
+                        totalTokens = { prompt: 0, completion: 0, total: 0 };
+                        totalCost = { prompt: 0, completion: 0, total: 0 };
+                        totalErrors = 0;
+                        totalLatency = 0;
+                        count = 0;
+                        _i = 0, _a = this.providers.values();
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        provider = _a[_i];
+                        return [4 /*yield*/, provider.getUsage(period)];
+                    case 2:
+                        usage = _b.sent();
+                        totalRequests += usage.requests;
+                        totalTokens.prompt += usage.tokens.prompt;
+                        totalTokens.completion += usage.tokens.completion;
+                        totalTokens.total += usage.tokens.total;
+                        totalCost.prompt += usage.cost.prompt;
+                        totalCost.completion += usage.cost.completion;
+                        totalCost.total += usage.cost.total;
+                        totalErrors += usage.errors;
+                        totalLatency += usage.averageLatency;
+                        count++;
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        now = new Date();
+                        start = new Date();
+                        start.setDate(start.getDate() - 1);
+                        return [2 /*return*/, {
+                                period: { start: start, end: now },
+                                requests: totalRequests,
+                                tokens: totalTokens,
+                                cost: __assign(__assign({}, totalCost), { currency: 'USD' }),
+                                errors: totalErrors,
+                                averageLatency: count > 0 ? totalLatency / count : 0,
+                                modelBreakdown: {},
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Get provider metrics
+     */
+    ProviderManager.prototype.getMetrics = function () {
+        return new Map(this.metrics);
+    };
+    /**
+     * Clear cache
+     */
+    ProviderManager.prototype.clearCache = function () {
+        this.cache.clear();
+        this.logger.info('Cache cleared');
+    };
+    /**
+     * Destroy all providers
+     */
+    ProviderManager.prototype.destroy = function () {
+        for (var _i = 0, _a = this.providers.values(); _i < _a.length; _i++) {
+            var provider = _a[_i];
+            provider.destroy();
+        }
+        this.providers.clear();
+        this.cache.clear();
+        this.metrics.clear();
+        this.removeAllListeners();
+        this.logger.info('Provider manager destroyed');
+    };
+    return ProviderManager;
+}(events_1.EventEmitter));
+exports.ProviderManager = ProviderManager;
+/**
+ * Create and initialize a provider manager
+ */
+function createProviderManager(config, logger) {
+    return __awaiter(this, void 0, void 0, function () {
+        var manager;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    manager = new ProviderManager(config, logger);
+                    return [4 /*yield*/, manager.initialize()];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/, manager];
+            }
+        });
+    });
+}