@flare-ai-sdk/server 1.0.0

package/dist/index.mjs

@@ -0,0 +1,2447 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw") throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object)) __typeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+
+// src/utils/errors.ts
+var FlareError = class extends Error {
+  constructor(message, code, statusCode, retryable = false, details) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "statusCode");
+    __publicField(this, "retryable");
+    __publicField(this, "details");
+    this.name = "FlareError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.retryable = retryable;
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var NetworkError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "NETWORK_ERROR", void 0, true, details);
+    this.name = "NetworkError";
+  }
+};
+var TimeoutError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "TIMEOUT_ERROR", 408, true, details);
+    this.name = "TimeoutError";
+  }
+};
+var RateLimitError = class extends FlareError {
+  constructor(message, retryAfter, details) {
+    super(message, "RATE_LIMIT_ERROR", 429, true, details);
+    __publicField(this, "retryAfter");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var AuthenticationError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "AUTHENTICATION_ERROR", 401, false, details);
+    this.name = "AuthenticationError";
+  }
+};
+var ValidationError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, false, details);
+    this.name = "ValidationError";
+  }
+};
+var CircuitBreakerError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "CIRCUIT_BREAKER_OPEN", 503, true, details);
+    this.name = "CircuitBreakerError";
+  }
+};
+var ProviderError = class extends FlareError {
+  constructor(provider, message, statusCode, details) {
+    super(message, "PROVIDER_ERROR", statusCode, true, details);
+    __publicField(this, "provider");
+    this.name = "ProviderError";
+    this.provider = provider;
+  }
+};
+var StreamError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "STREAM_ERROR", void 0, false, details);
+    this.name = "StreamError";
+  }
+};
+var ParseError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "PARSE_ERROR", void 0, false, details);
+    this.name = "ParseError";
+  }
+};
+var ContentFilterError = class extends FlareError {
+  constructor(message, details) {
+    super(message, "CONTENT_FILTER_ERROR", 400, false, details);
+    this.name = "ContentFilterError";
+  }
+};
+function isRetryableError(error) {
+  if (error instanceof FlareError) {
+    return error.retryable;
+  }
+  if (error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("ENOTFOUND")) {
+    return true;
+  }
+  return false;
+}
+function getErrorStatusCode(error) {
+  if (error instanceof FlareError) {
+    return error.statusCode;
+  }
+  return void 0;
+}
+
+// src/utils/metrics.ts
+var LatencyHistogram = class {
+  constructor() {
+    __publicField(this, "samples", []);
+    __publicField(this, "maxSamples", 1e3);
+  }
+  add(latency) {
+    this.samples.push(latency);
+    if (this.samples.length > this.maxSamples) {
+      this.samples.shift();
+    }
+  }
+  getPercentile(p) {
+    if (this.samples.length === 0) return 0;
+    const sorted = [...this.samples].sort((a, b) => a - b);
+    const index = Math.ceil(p / 100 * sorted.length) - 1;
+    return sorted[Math.max(0, index)];
+  }
+  getAverage() {
+    if (this.samples.length === 0) return 0;
+    return this.samples.reduce((a, b) => a + b, 0) / this.samples.length;
+  }
+  clear() {
+    this.samples = [];
+  }
+};
+var MetricsCollector = class {
+  constructor() {
+    __publicField(this, "totalRequests", 0);
+    __publicField(this, "successfulRequests", 0);
+    __publicField(this, "failedRequests", 0);
+    __publicField(this, "latencyHistogram", new LatencyHistogram());
+    __publicField(this, "startTime", Date.now());
+    __publicField(this, "windowStart", Date.now());
+    __publicField(this, "windowRequests", 0);
+    __publicField(this, "windowDuration", 6e4);
+  }
+  // 1 minute window
+  /**
+   * Record successful request
+   * @param latency - Request latency in milliseconds
+   */
+  recordSuccess(latency) {
+    this.totalRequests++;
+    this.successfulRequests++;
+    this.latencyHistogram.add(latency);
+    this.updateWindow();
+  }
+  /**
+   * Record failed request
+   * @param latency - Request latency in milliseconds
+   */
+  recordFailure(latency) {
+    this.totalRequests++;
+    this.failedRequests++;
+    this.latencyHistogram.add(latency);
+    this.updateWindow();
+  }
+  /**
+   * Update rolling window for RPS calculation
+   */
+  updateWindow() {
+    const now = Date.now();
+    if (now - this.windowStart >= this.windowDuration) {
+      this.windowRequests = 0;
+      this.windowStart = now;
+    }
+    this.windowRequests++;
+  }
+  /**
+   * Get current metrics
+   */
+  getMetrics() {
+    const elapsed = (Date.now() - this.windowStart) / 1e3;
+    const rps = elapsed > 0 ? this.windowRequests / elapsed : 0;
+    return {
+      totalRequests: this.totalRequests,
+      successfulRequests: this.successfulRequests,
+      failedRequests: this.failedRequests,
+      avgLatency: this.latencyHistogram.getAverage(),
+      p95Latency: this.latencyHistogram.getPercentile(95),
+      p99Latency: this.latencyHistogram.getPercentile(99),
+      rps
+    };
+  }
+  /**
+   * Get success rate as percentage
+   */
+  getSuccessRate() {
+    if (this.totalRequests === 0) return 100;
+    return this.successfulRequests / this.totalRequests * 100;
+  }
+  /**
+   * Get uptime in milliseconds
+   */
+  getUptime() {
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Reset all metrics
+   */
+  reset() {
+    this.totalRequests = 0;
+    this.successfulRequests = 0;
+    this.failedRequests = 0;
+    this.latencyHistogram.clear();
+    this.windowStart = Date.now();
+    this.windowRequests = 0;
+  }
+  /**
+   * Get detailed statistics
+   */
+  getDetailedStats() {
+    return __spreadProps(__spreadValues({}, this.getMetrics()), {
+      successRate: this.getSuccessRate(),
+      uptime: this.getUptime(),
+      timestamp: Date.now()
+    });
+  }
+};
+var globalMetrics = null;
+function getGlobalMetrics() {
+  if (!globalMetrics) {
+    globalMetrics = new MetricsCollector();
+  }
+  return globalMetrics;
+}
+function createMetricsCollector() {
+  return new MetricsCollector();
+}
+function measureLatency(_0) {
+  return __async(this, arguments, function* (fn, collector = getGlobalMetrics()) {
+    const start = Date.now();
+    try {
+      const result = yield fn();
+      collector.recordSuccess(Date.now() - start);
+      return result;
+    } catch (error) {
+      collector.recordFailure(Date.now() - start);
+      throw error;
+    }
+  });
+}
+
+// src/utils/rate-limiter.ts
+var DEFAULT_CONFIG = {
+  maxRequests: 100,
+  windowMs: 6e4,
+  // 1 minute
+  clientId: "default"
+};
+var RateLimiter = class {
+  constructor(config = {}) {
+    __publicField(this, "buckets", /* @__PURE__ */ new Map());
+    __publicField(this, "config");
+    __publicField(this, "cleanupInterval");
+    this.config = __spreadValues(__spreadValues({}, DEFAULT_CONFIG), config);
+    this.startCleanup();
+  }
+  /**
+   * Acquire a token for rate limiting
+   * @param clientId - Client identifier
+   * @throws RateLimitError if rate limit exceeded
+   */
+  acquire(clientId) {
+    return __async(this, null, function* () {
+      const id = clientId || this.config.clientId;
+      const bucket = this.getBucket(id);
+      this.refillBucket(bucket);
+      if (bucket.tokens <= 0) {
+        const retryAfter = this.calculateRetryAfter(bucket);
+        throw new RateLimitError(
+          `Rate limit exceeded. Try again in ${Math.ceil(retryAfter / 1e3)}s`,
+          retryAfter,
+          { clientId: id, limit: this.config.maxRequests, window: this.config.windowMs }
+        );
+      }
+      bucket.tokens--;
+    });
+  }
+  /**
+   * Check if request would be allowed without consuming token
+   * @param clientId - Client identifier
+   * @returns true if request would be allowed
+   */
+  check(clientId) {
+    const id = clientId || this.config.clientId;
+    const bucket = this.getBucket(id);
+    this.refillBucket(bucket);
+    return bucket.tokens > 0;
+  }
+  /**
+   * Get remaining tokens for client
+   * @param clientId - Client identifier
+   * @returns Number of remaining requests
+   */
+  getRemaining(clientId) {
+    const id = clientId || this.config.clientId;
+    const bucket = this.getBucket(id);
+    this.refillBucket(bucket);
+    return Math.floor(bucket.tokens);
+  }
+  /**
+   * Reset rate limit for client
+   * @param clientId - Client identifier
+   */
+  reset(clientId) {
+    const id = clientId || this.config.clientId;
+    this.buckets.delete(id);
+  }
+  /**
+   * Get or create bucket for client
+   */
+  getBucket(clientId) {
+    let bucket = this.buckets.get(clientId);
+    if (!bucket) {
+      bucket = {
+        tokens: this.config.maxRequests,
+        lastRefill: Date.now()
+      };
+      this.buckets.set(clientId, bucket);
+    }
+    return bucket;
+  }
+  /**
+   * Refill tokens based on elapsed time
+   */
+  refillBucket(bucket) {
+    const now = Date.now();
+    const elapsed = now - bucket.lastRefill;
+    if (elapsed <= 0) return;
+    const tokensToAdd = elapsed / this.config.windowMs * this.config.maxRequests;
+    bucket.tokens = Math.min(this.config.maxRequests, bucket.tokens + tokensToAdd);
+    bucket.lastRefill = now;
+  }
+  /**
+   * Calculate retry-after time in milliseconds
+   */
+  calculateRetryAfter(bucket) {
+    const tokensNeeded = 1 - bucket.tokens;
+    return tokensNeeded / this.config.maxRequests * this.config.windowMs;
+  }
+  /**
+   * Start periodic cleanup of old buckets
+   */
+  startCleanup() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      const maxAge = this.config.windowMs * 2;
+      for (const [clientId, bucket] of this.buckets.entries()) {
+        if (now - bucket.lastRefill > maxAge) {
+          this.buckets.delete(clientId);
+        }
+      }
+    }, this.config.windowMs);
+    if (this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
+  }
+  /**
+   * Get statistics for monitoring
+   */
+  getStats() {
+    return {
+      totalClients: this.buckets.size,
+      config: this.config
+    };
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.buckets.clear();
+  }
+};
+function createRateLimiter(config) {
+  return new RateLimiter(config);
+}
+
+// src/utils/request-queue.ts
+import EventEmitter from "eventemitter3";
+var DEFAULT_CONFIG2 = {
+  concurrency: 10,
+  maxQueueSize: 1e3,
+  timeout: 3e4
+};
+var RequestQueue = class extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    __publicField(this, "queue", []);
+    __publicField(this, "running", 0);
+    __publicField(this, "config");
+    __publicField(this, "requestCounter", 0);
+    this.config = __spreadValues(__spreadValues({}, DEFAULT_CONFIG2), config);
+  }
+  /**
+   * Add request to queue
+   * @param fn - Async function to execute
+   * @param priority - Request priority (higher = processed first)
+   * @returns Promise resolving to function result
+   */
+  add(fn, priority = 0) {
+    return new Promise((resolve, reject) => {
+      if (this.queue.length >= this.config.maxQueueSize) {
+        reject(new Error("Queue is full"));
+        return;
+      }
+      const item = {
+        id: `req_${++this.requestCounter}`,
+        priority,
+        fn,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      };
+      const insertIndex = this.queue.findIndex((q) => q.priority < priority);
+      if (insertIndex === -1) {
+        this.queue.push(item);
+      } else {
+        this.queue.splice(insertIndex, 0, item);
+      }
+      this.emit("enqueue", { id: item.id, priority, queueSize: this.queue.length });
+      this.process();
+    });
+  }
+  /**
+   * Process queue items
+   */
+  process() {
+    return __async(this, null, function* () {
+      while (this.running < this.config.concurrency && this.queue.length > 0) {
+        const item = this.queue.shift();
+        this.running++;
+        this.emit("start", { id: item.id, running: this.running });
+        this.executeItem(item).finally(() => {
+          this.running--;
+          this.emit("complete", { id: item.id, running: this.running });
+          if (this.running === 0 && this.queue.length === 0) {
+            this.emit("drain");
+          }
+          this.process();
+        });
+      }
+    });
+  }
+  /**
+   * Execute queue item with timeout
+   */
+  executeItem(item) {
+    return __async(this, null, function* () {
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`Request timeout after ${this.config.timeout}ms`));
+        }, this.config.timeout);
+      });
+      try {
+        const result = yield Promise.race([item.fn(), timeoutPromise]);
+        item.resolve(result);
+      } catch (error) {
+        item.reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  /**
+   * Get queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Get number of running requests
+   */
+  getRunning() {
+    return this.running;
+  }
+  /**
+   * Check if queue is empty
+   */
+  isEmpty() {
+    return this.queue.length === 0 && this.running === 0;
+  }
+  /**
+   * Clear all pending requests
+   */
+  clear() {
+    const error = new Error("Queue cleared");
+    for (const item of this.queue) {
+      item.reject(error);
+    }
+    this.queue = [];
+    this.emit("clear");
+  }
+  /**
+   * Wait for queue to drain
+   */
+  drain() {
+    return __async(this, null, function* () {
+      if (this.isEmpty()) return;
+      return new Promise((resolve) => {
+        this.once("drain", resolve);
+      });
+    });
+  }
+  /**
+   * Get queue statistics
+   */
+  getStats() {
+    return {
+      queueSize: this.queue.length,
+      running: this.running,
+      concurrency: this.config.concurrency,
+      maxQueueSize: this.config.maxQueueSize
+    };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = __spreadValues(__spreadValues({}, this.config), config);
+    this.process();
+  }
+};
+function createRequestQueue(config) {
+  return new RequestQueue(config);
+}
+
+// src/utils/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  maxDelay: 3e4,
+  backoffMultiplier: 2,
+  jitter: true
+};
+function calculateDelay(attempt, config) {
+  const exponentialDelay = Math.min(
+    config.initialDelay * Math.pow(config.backoffMultiplier, attempt),
+    config.maxDelay
+  );
+  if (config.jitter) {
+    return Math.random() * exponentialDelay;
+  }
+  return exponentialDelay;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withRetry(_0) {
+  return __async(this, arguments, function* (fn, config = {}, onRetry) {
+    const retryConfig = __spreadValues(__spreadValues({}, DEFAULT_RETRY_CONFIG), config);
+    let lastError;
+    for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+      try {
+        return yield fn();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (!isRetryableError(lastError) || attempt === retryConfig.maxRetries) {
+          throw lastError;
+        }
+        const delay = calculateDelay(attempt, retryConfig);
+        if (onRetry) {
+          onRetry(attempt + 1, lastError, delay);
+        }
+        yield sleep(delay);
+      }
+    }
+    throw lastError;
+  });
+}
+var RetryHandler = class {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    this.config = __spreadValues(__spreadValues({}, DEFAULT_RETRY_CONFIG), config);
+  }
+  /**
+   * Execute function with retry logic
+   */
+  execute(fn, onRetry) {
+    return __async(this, null, function* () {
+      return withRetry(fn, this.config, onRetry);
+    });
+  }
+  /**
+   * Update retry configuration
+   */
+  updateConfig(config) {
+    this.config = __spreadValues(__spreadValues({}, this.config), config);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return __spreadValues({}, this.config);
+  }
+};
+function createRetryHandler(config) {
+  return new RetryHandler(config);
+}
+
+// src/utils/circuit-breaker.ts
+import EventEmitter2 from "eventemitter3";
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "closed";
+  CircuitState2["OPEN"] = "open";
+  CircuitState2["HALF_OPEN"] = "half-open";
+  return CircuitState2;
+})(CircuitState || {});
+var DEFAULT_CONFIG3 = {
+  failureThreshold: 5,
+  resetTimeout: 6e4,
+  halfOpenRequests: 1
+};
+var CircuitBreaker = class extends EventEmitter2 {
+  constructor(config = {}) {
+    super();
+    __publicField(this, "state", "closed" /* CLOSED */);
+    __publicField(this, "failureCount", 0);
+    __publicField(this, "successCount", 0);
+    __publicField(this, "lastFailureTime");
+    __publicField(this, "resetTimer");
+    __publicField(this, "config");
+    this.config = __spreadValues(__spreadValues({}, DEFAULT_CONFIG3), config);
+  }
+  /**
+   * Execute a function with circuit breaker protection
+   * @param fn - Async function to execute
+   * @returns Promise resolving to function result
+   * @throws CircuitBreakerError if circuit is open
+   */
+  execute(fn) {
+    return __async(this, null, function* () {
+      if (this.state === "open" /* OPEN */) {
+        throw new CircuitBreakerError("Circuit breaker is open", {
+          state: this.state,
+          failureCount: this.failureCount,
+          lastFailureTime: this.lastFailureTime
+        });
+      }
+      try {
+        const result = yield fn();
+        this.onSuccess();
+        return result;
+      } catch (error) {
+        this.onFailure();
+        throw error;
+      }
+    });
+  }
+  /**
+   * Handle successful execution
+   */
+  onSuccess() {
+    this.failureCount = 0;
+    if (this.state === "half-open" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.config.halfOpenRequests) {
+        this.close();
+      }
+    }
+  }
+  /**
+   * Handle failed execution
+   */
+  onFailure() {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    this.successCount = 0;
+    if (this.failureCount >= this.config.failureThreshold) {
+      this.open();
+    }
+  }
+  /**
+   * Open the circuit (block requests)
+   */
+  open() {
+    if (this.state === "open" /* OPEN */) return;
+    this.state = "open" /* OPEN */;
+    this.emit("open", { failureCount: this.failureCount });
+    this.resetTimer = setTimeout(() => {
+      this.halfOpen();
+    }, this.config.resetTimeout);
+  }
+  /**
+   * Enter half-open state (test if service recovered)
+   */
+  halfOpen() {
+    if (this.state === "closed" /* CLOSED */) return;
+    this.state = "half-open" /* HALF_OPEN */;
+    this.successCount = 0;
+    this.emit("half-open");
+  }
+  /**
+   * Close the circuit (allow requests)
+   */
+  close() {
+    if (this.state === "closed" /* CLOSED */) return;
+    this.state = "closed" /* CLOSED */;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = void 0;
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+      this.resetTimer = void 0;
+    }
+    this.emit("close");
+  }
+  /**
+   * Get current circuit state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get circuit statistics
+   */
+  getStats() {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      successCount: this.successCount,
+      lastFailureTime: this.lastFailureTime
+    };
+  }
+  /**
+   * Manually reset the circuit breaker
+   */
+  reset() {
+    this.close();
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    if (this.resetTimer) {
+      clearTimeout(this.resetTimer);
+    }
+    this.removeAllListeners();
+  }
+};
+function createCircuitBreaker(config) {
+  return new CircuitBreaker(config);
+}
+
+// src/providers/base.ts
+var BaseProvider = class {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  makeRequest(url, options, stream = false) {
+    return __async(this, null, function* () {
+      const headers = __spreadValues({
+        "Content-Type": "application/json"
+      }, options.headers || {});
+      if (this.config.apiKey) {
+        headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+      }
+      const response = yield fetch(url, __spreadProps(__spreadValues({}, options), {
+        headers
+      }));
+      if (!response.ok && !stream) {
+        const errorText = yield response.text();
+        throw new Error(`Provider request failed: ${response.status} ${errorText}`);
+      }
+      return response;
+    });
+  }
+  formatMessages(request) {
+    const messages = [];
+    if (request.systemPrompt) {
+      messages.push({ role: "system", content: request.systemPrompt });
+    }
+    messages.push(...request.messages);
+    return messages;
+  }
+  getEndpoint(path) {
+    const baseUrl = this.config.baseUrl || this.getDefaultBaseUrl();
+    return `${baseUrl}${path}`;
+  }
+};
+
+// src/providers/anthropic/anthropic.ts
+var AnthropicProvider = class extends BaseProvider {
+  getDefaultBaseUrl() {
+    return "https://api.anthropic.com/v1";
+  }
+  generateText(request) {
+    return __async(this, null, function* () {
+      var _a;
+      const messages = this.formatMessages(request);
+      const systemPrompt = (_a = messages.find((m) => m.role === "system")) == null ? void 0 : _a.content;
+      const userMessages = messages.filter((m) => m.role !== "system");
+      const response = yield this.makeRequest(
+        this.getEndpoint("/messages"),
+        {
+          method: "POST",
+          headers: {
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify({
+            model: this.config.model,
+            messages: userMessages,
+            system: systemPrompt,
+            max_tokens: this.config.maxTokens || 1024,
+            temperature: this.config.temperature
+          })
+        }
+      );
+      const data = yield response.json();
+      return {
+        text: data.content[0].text,
+        usage: {
+          promptTokens: data.usage.input_tokens,
+          completionTokens: data.usage.output_tokens,
+          totalTokens: data.usage.input_tokens + data.usage.output_tokens
+        },
+        finishReason: data.stop_reason
+      };
+    });
+  }
+  streamText(request) {
+    return __asyncGenerator(this, null, function* () {
+      var _a;
+      const messages = this.formatMessages(request);
+      const systemPrompt = (_a = messages.find((m) => m.role === "system")) == null ? void 0 : _a.content;
+      const userMessages = messages.filter((m) => m.role !== "system");
+      const response = yield new __await(this.makeRequest(
+        this.getEndpoint("/messages"),
+        {
+          method: "POST",
+          headers: {
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify({
+            model: this.config.model,
+            messages: userMessages,
+            system: systemPrompt,
+            max_tokens: this.config.maxTokens || 1024,
+            stream: true
+          })
+        },
+        true
+      ));
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = yield new __await(reader.read());
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              try {
+                const data = JSON.parse(line.slice(6));
+                if (data.type === "content_block_delta") {
+                  yield { type: "content", content: data.delta.text };
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  }
+  generateObject(request) {
+    return __async(this, null, function* () {
+      const textResponse = yield this.generateText(__spreadProps(__spreadValues({}, request), {
+        messages: [
+          ...request.messages,
+          {
+            role: "user",
+            content: `Respond with valid JSON matching this schema: ${JSON.stringify(request.schema)}`
+          }
+        ]
+      }));
+      const object = JSON.parse(textResponse.text);
+      return {
+        object,
+        text: textResponse.text,
+        usage: textResponse.usage
+      };
+    });
+  }
+  streamObject(request) {
+    return __asyncGenerator(this, null, function* () {
+      let accumulatedText = "";
+      try {
+        for (var iter = __forAwait(this.streamText(request)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          if (chunk.type === "content") {
+            accumulatedText += chunk.content;
+            try {
+              const partial = JSON.parse(accumulatedText);
+              yield { type: "partial", partial, text: accumulatedText };
+            } catch (e) {
+            }
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      try {
+        const object = JSON.parse(accumulatedText);
+        yield { type: "complete", object, text: accumulatedText };
+      } catch (e) {
+        yield { type: "error", error: new Error("Invalid JSON in response") };
+      }
+    });
+  }
+};
+
+// src/providers/custom/custom.ts
+var CustomProvider = class extends BaseProvider {
+  constructor() {
+    super(...arguments);
+    /**
+     * Request format for custom provider
+     */
+    __publicField(this, "requestFormat", "openai");
+  }
+  getDefaultBaseUrl() {
+    return this.config.baseUrl || "http://localhost:8000/v1";
+  }
+  /**
+   * Set request format for custom provider
+   */
+  setRequestFormat(format) {
+    this.requestFormat = format;
+  }
+  generateText(request) {
+    return __async(this, null, function* () {
+      const messages = this.formatMessages(request);
+      try {
+        const requestBody = this.formatRequestBody(messages, false);
+        const response = yield this.makeRequest(this.getEndpoint("/chat/completions"), {
+          method: "POST",
+          body: JSON.stringify(requestBody)
+        });
+        const data = yield response.json();
+        return this.parseTextResponse(data);
+      } catch (error) {
+        throw new ProviderError(
+          "custom",
+          error instanceof Error ? error.message : "Unknown error",
+          void 0,
+          { originalError: error }
+        );
+      }
+    });
+  }
+  streamText(request) {
+    return __asyncGenerator(this, null, function* () {
+      const messages = this.formatMessages(request);
+      try {
+        const requestBody = this.formatRequestBody(messages, true);
+        const response = yield new __await(this.makeRequest(
+          this.getEndpoint("/chat/completions"),
+          {
+            method: "POST",
+            body: JSON.stringify(requestBody)
+          },
+          true
+        ));
+        yield* __yieldStar(this.parseStreamResponse(response));
+      } catch (error) {
+        yield {
+          type: "error",
+          error: new ProviderError(
+            "custom",
+            error instanceof Error ? error.message : "Streaming error",
+            void 0,
+            { originalError: error }
+          )
+        };
+      }
+    });
+  }
+  generateObject(request) {
+    return __async(this, null, function* () {
+      const enhancedRequest = __spreadProps(__spreadValues({}, request), {
+        messages: [
+          ...request.messages,
+          {
+            role: "user",
+            content: `Respond with valid JSON matching this schema: ${JSON.stringify(request.schema)}. Only return the JSON object.`
+          }
+        ]
+      });
+      const textResponse = yield this.generateText(enhancedRequest);
+      let jsonText = textResponse.text.trim();
+      const codeBlockMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+      if (codeBlockMatch) {
+        jsonText = codeBlockMatch[1];
+      }
+      try {
+        const object = JSON.parse(jsonText);
+        return {
+          object,
+          text: textResponse.text,
+          usage: textResponse.usage
+        };
+      } catch (error) {
+        throw new ProviderError(
+          "custom",
+          `Failed to parse JSON response: ${error instanceof Error ? error.message : "Unknown error"}`,
+          void 0,
+          { responseText: textResponse.text }
+        );
+      }
+    });
+  }
+  streamObject(request) {
+    return __asyncGenerator(this, null, function* () {
+      let accumulatedText = "";
+      try {
+        for (var iter = __forAwait(this.streamText(request)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          if (chunk.type === "content") {
+            accumulatedText += chunk.content;
+            let jsonText2 = accumulatedText.trim();
+            const codeBlockMatch2 = jsonText2.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+            if (codeBlockMatch2) {
+              jsonText2 = codeBlockMatch2[1];
+            }
+            try {
+              const partial = JSON.parse(jsonText2);
+              yield { type: "partial", partial, text: accumulatedText };
+            } catch (e) {
+            }
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      let jsonText = accumulatedText.trim();
+      const codeBlockMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+      if (codeBlockMatch) {
+        jsonText = codeBlockMatch[1];
+      }
+      try {
+        const object = JSON.parse(jsonText);
+        yield { type: "complete", object, text: accumulatedText };
+      } catch (e) {
+        yield { type: "error", error: new Error("Invalid JSON in response") };
+      }
+    });
+  }
+  /**
+   * Format request body based on provider format
+   */
+  formatRequestBody(messages, stream) {
+    var _a;
+    if (this.requestFormat === "anthropic") {
+      const systemPrompt = (_a = messages.find((m) => m.role === "system")) == null ? void 0 : _a.content;
+      const userMessages = messages.filter((m) => m.role !== "system");
+      return {
+        model: this.config.model,
+        messages: userMessages,
+        system: systemPrompt,
+        max_tokens: this.config.maxTokens || 1024,
+        temperature: this.config.temperature,
+        top_p: this.config.topP,
+        stream
+      };
+    }
+    return {
+      model: this.config.model,
+      messages,
+      max_tokens: this.config.maxTokens,
+      temperature: this.config.temperature,
+      top_p: this.config.topP,
+      frequency_penalty: this.config.frequencyPenalty,
+      presence_penalty: this.config.presencePenalty,
+      stop: this.config.stop,
+      stream
+    };
+  }
+  /**
+   * Parse text response based on provider format
+   */
+  parseTextResponse(data) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (data.choices && ((_a = data.choices[0]) == null ? void 0 : _a.message)) {
+      return {
+        text: data.choices[0].message.content,
+        usage: {
+          promptTokens: ((_b = data.usage) == null ? void 0 : _b.prompt_tokens) || 0,
+          completionTokens: ((_c = data.usage) == null ? void 0 : _c.completion_tokens) || 0,
+          totalTokens: ((_d = data.usage) == null ? void 0 : _d.total_tokens) || 0
+        },
+        finishReason: data.choices[0].finish_reason || "stop"
+      };
+    }
+    if (data.content && Array.isArray(data.content)) {
+      return {
+        text: ((_e = data.content[0]) == null ? void 0 : _e.text) || "",
+        usage: {
+          promptTokens: ((_f = data.usage) == null ? void 0 : _f.input_tokens) || 0,
+          completionTokens: ((_g = data.usage) == null ? void 0 : _g.output_tokens) || 0,
+          totalTokens: (((_h = data.usage) == null ? void 0 : _h.input_tokens) || 0) + (((_i = data.usage) == null ? void 0 : _i.output_tokens) || 0)
+        },
+        finishReason: data.stop_reason || "stop"
+      };
+    }
+    return {
+      text: data.text || data.response || JSON.stringify(data),
+      usage: {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0
+      },
+      finishReason: "stop"
+    };
+  }
+  /**
+   * Parse streaming response
+   */
+  parseStreamResponse(response) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = yield new __await(reader.read());
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") continue;
+              try {
+                const parsed = JSON.parse(data);
+                if ((_c = (_b = (_a = parsed.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.delta) == null ? void 0 : _c.content) {
+                  yield { type: "content", content: parsed.choices[0].delta.content };
+                }
+                if (parsed.type === "content_block_delta" && ((_d = parsed.delta) == null ? void 0 : _d.text)) {
+                  yield { type: "content", content: parsed.delta.text };
+                }
+                if (parsed.content && !parsed.choices) {
+                  yield { type: "content", content: parsed.content };
+                }
+                if (((_f = (_e = parsed.choices) == null ? void 0 : _e[0]) == null ? void 0 : _f.finish_reason) || parsed.stop_reason) {
+                  yield {
+                    type: "done",
+                    done: {
+                      finishReason: ((_h = (_g = parsed.choices) == null ? void 0 : _g[0]) == null ? void 0 : _h.finish_reason) || parsed.stop_reason || "stop",
+                      usage: {
+                        promptTokens: ((_i = parsed.usage) == null ? void 0 : _i.prompt_tokens) || ((_j = parsed.usage) == null ? void 0 : _j.input_tokens) || 0,
+                        completionTokens: ((_k = parsed.usage) == null ? void 0 : _k.completion_tokens) || ((_l = parsed.usage) == null ? void 0 : _l.output_tokens) || 0,
+                        totalTokens: ((_m = parsed.usage) == null ? void 0 : _m.total_tokens) || 0
+                      }
+                    }
+                  };
+                }
+              } catch (e) {
+                console.error("Failed to parse streaming chunk:", e);
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  }
+};
+
+// src/providers/google/google.ts
+var GoogleProvider = class extends BaseProvider {
+  getDefaultBaseUrl() {
+    return "https://generativelanguage.googleapis.com/v1beta";
+  }
+  /**
+   * Format messages for Google's API format
+   */
+  formatGoogleMessages(messages) {
+    return messages.map((msg) => ({
+      role: msg.role === "assistant" ? "model" : msg.role,
+      parts: [{ text: msg.content }]
+    }));
+  }
+  generateText(request) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const messages = this.formatMessages(request);
+      const systemPrompt = (_a = messages.find((m) => m.role === "system")) == null ? void 0 : _a.content;
+      const conversationMessages = messages.filter((m) => m.role !== "system");
+      const endpoint = this.getEndpoint(
+        `/models/${this.config.model}:generateContent?key=${this.config.apiKey}`
+      );
+      try {
+        const response = yield this.makeRequest(endpoint, {
+          method: "POST",
+          body: JSON.stringify({
+            contents: this.formatGoogleMessages(conversationMessages),
+            systemInstruction: systemPrompt ? {
+              parts: [{ text: systemPrompt }]
+            } : void 0,
+            generationConfig: {
+              maxOutputTokens: this.config.maxTokens,
+              temperature: this.config.temperature,
+              topP: this.config.topP,
+              stopSequences: this.config.stop
+            }
+          })
+        });
+        const data = yield response.json();
+        if (!data.candidates || data.candidates.length === 0) {
+          throw new ProviderError(
+            "google",
+            "No candidates returned from Google API",
+            response.status,
+            { response: data }
+          );
+        }
+        const candidate = data.candidates[0];
+        const text = candidate.content.parts.map((p) => p.text).join("");
+        return {
+          text,
+          usage: {
+            promptTokens: ((_b = data.usageMetadata) == null ? void 0 : _b.promptTokenCount) || 0,
+            completionTokens: ((_c = data.usageMetadata) == null ? void 0 : _c.candidatesTokenCount) || 0,
+            totalTokens: ((_d = data.usageMetadata) == null ? void 0 : _d.totalTokenCount) || 0
+          },
+          finishReason: this.mapGoogleFinishReason(candidate.finishReason),
+          metadata: {
+            safetyRatings: candidate.safetyRatings
+          }
+        };
+      } catch (error) {
+        throw new ProviderError(
+          "google",
+          error instanceof Error ? error.message : "Unknown error",
+          void 0,
+          { originalError: error }
+        );
+      }
+    });
+  }
+  streamText(request) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g;
+      const messages = this.formatMessages(request);
+      const systemPrompt = (_a = messages.find((m) => m.role === "system")) == null ? void 0 : _a.content;
+      const conversationMessages = messages.filter((m) => m.role !== "system");
+      const endpoint = this.getEndpoint(
+        `/models/${this.config.model}:streamGenerateContent?key=${this.config.apiKey}`
+      );
+      try {
+        const response = yield new __await(this.makeRequest(
+          endpoint,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              contents: this.formatGoogleMessages(conversationMessages),
+              systemInstruction: systemPrompt ? {
+                parts: [{ text: systemPrompt }]
+              } : void 0,
+              generationConfig: {
+                maxOutputTokens: this.config.maxTokens,
+                temperature: this.config.temperature,
+                topP: this.config.topP
+              }
+            })
+          },
+          true
+        ));
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = yield new __await(reader.read());
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim() || !line.startsWith("data: ")) continue;
+            try {
+              const jsonStr = line.slice(6).trim();
+              if (!jsonStr) continue;
+              const data = JSON.parse(jsonStr);
+              if (data.candidates && ((_c = (_b = data.candidates[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts)) {
+                const text = data.candidates[0].content.parts.map((p) => p.text).join("");
+                if (text) {
+                  yield { type: "content", content: text };
+                }
+              }
+              if (data.candidates && ((_d = data.candidates[0]) == null ? void 0 : _d.finishReason)) {
+                yield {
+                  type: "done",
+                  done: {
+                    finishReason: this.mapGoogleFinishReason(data.candidates[0].finishReason),
+                    usage: {
+                      promptTokens: ((_e = data.usageMetadata) == null ? void 0 : _e.promptTokenCount) || 0,
+                      completionTokens: ((_f = data.usageMetadata) == null ? void 0 : _f.candidatesTokenCount) || 0,
+                      totalTokens: ((_g = data.usageMetadata) == null ? void 0 : _g.totalTokenCount) || 0
+                    }
+                  }
+                };
+              }
+            } catch (e) {
+              console.error("Failed to parse Google streaming response:", e);
+            }
+          }
+        }
+      } catch (error) {
+        yield {
+          type: "error",
+          error: new ProviderError(
+            "google",
+            error instanceof Error ? error.message : "Streaming error",
+            void 0,
+            { originalError: error }
+          )
+        };
+      }
+    });
+  }
+  generateObject(request) {
+    return __async(this, null, function* () {
+      const enhancedRequest = __spreadProps(__spreadValues({}, request), {
+        messages: [
+          ...request.messages,
+          {
+            role: "user",
+            content: `Respond with valid JSON matching this schema: ${JSON.stringify(request.schema)}. Only return the JSON object, no other text.`
+          }
+        ]
+      });
+      const textResponse = yield this.generateText(enhancedRequest);
+      let jsonText = textResponse.text.trim();
+      const jsonMatch = jsonText.match(/```json\s*([\s\S]*?)\s*```/);
+      if (jsonMatch) {
+        jsonText = jsonMatch[1];
+      }
+      try {
+        const object = JSON.parse(jsonText);
+        return {
+          object,
+          text: textResponse.text,
+          usage: textResponse.usage
+        };
+      } catch (error) {
+        throw new ProviderError(
+          "google",
+          `Failed to parse JSON response: ${error instanceof Error ? error.message : "Unknown error"}`,
+          void 0,
+          { responseText: textResponse.text }
+        );
+      }
+    });
+  }
+  streamObject(request) {
+    return __asyncGenerator(this, null, function* () {
+      let accumulatedText = "";
+      try {
+        for (var iter = __forAwait(this.streamText(request)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          if (chunk.type === "content") {
+            accumulatedText += chunk.content;
+            let jsonText2 = accumulatedText.trim();
+            const jsonMatch2 = jsonText2.match(/```json\s*([\s\S]*?)\s*```/);
+            if (jsonMatch2) {
+              jsonText2 = jsonMatch2[1];
+            }
+            try {
+              const partial = JSON.parse(jsonText2);
+              yield { type: "partial", partial, text: accumulatedText };
+            } catch (e) {
+            }
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      let jsonText = accumulatedText.trim();
+      const jsonMatch = jsonText.match(/```json\s*([\s\S]*?)\s*```/);
+      if (jsonMatch) {
+        jsonText = jsonMatch[1];
+      }
+      try {
+        const object = JSON.parse(jsonText);
+        yield { type: "complete", object, text: accumulatedText };
+      } catch (e) {
+        yield {
+          type: "error",
+          error: new Error(`Invalid JSON in response: ${accumulatedText.substring(0, 100)}...`)
+        };
+      }
+    });
+  }
+  /**
+   * Map Google's finish reason to standard format
+   */
+  mapGoogleFinishReason(reason) {
+    const mapping = {
+      "STOP": "stop",
+      "MAX_TOKENS": "length",
+      "SAFETY": "content_filter",
+      "RECITATION": "content_filter",
+      "OTHER": "stop"
+    };
+    return mapping[reason] || "stop";
+  }
+};
+
+// src/providers/openai/openai.ts
+var OpenAIProvider = class extends BaseProvider {
+  getDefaultBaseUrl() {
+    return "https://api.openai.com/v1";
+  }
+  generateText(request) {
+    return __async(this, null, function* () {
+      const response = yield this.makeRequest(
+        this.getEndpoint("/chat/completions"),
+        {
+          method: "POST",
+          body: JSON.stringify({
+            model: this.config.model,
+            messages: this.formatMessages(request),
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            top_p: this.config.topP,
+            frequency_penalty: this.config.frequencyPenalty,
+            presence_penalty: this.config.presencePenalty,
+            stop: this.config.stop
+          })
+        }
+      );
+      const data = yield response.json();
+      return {
+        text: data.choices[0].message.content,
+        usage: {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        },
+        finishReason: data.choices[0].finish_reason
+      };
+    });
+  }
+  streamText(request) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b;
+      const response = yield new __await(this.makeRequest(
+        this.getEndpoint("/chat/completions"),
+        {
+          method: "POST",
+          body: JSON.stringify({
+            model: this.config.model,
+            messages: this.formatMessages(request),
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            stream: true
+          })
+        },
+        true
+      ));
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = yield new __await(reader.read());
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") continue;
+              try {
+                const parsed = JSON.parse(data);
+                const content = (_b = (_a = parsed.choices[0]) == null ? void 0 : _a.delta) == null ? void 0 : _b.content;
+                if (content) {
+                  yield { type: "content", content };
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    });
+  }
+  generateObject(request) {
+    return __async(this, null, function* () {
+      const textResponse = yield this.generateText(__spreadProps(__spreadValues({}, request), {
+        messages: [
+          ...request.messages,
+          {
+            role: "system",
+            content: `Respond with valid JSON matching this schema: ${JSON.stringify(request.schema)}`
+          }
+        ]
+      }));
+      const object = JSON.parse(textResponse.text);
+      return {
+        object,
+        text: textResponse.text,
+        usage: textResponse.usage
+      };
+    });
+  }
+  streamObject(request) {
+    return __asyncGenerator(this, null, function* () {
+      let accumulatedText = "";
+      try {
+        for (var iter = __forAwait(this.streamText(request)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          if (chunk.type === "content") {
+            accumulatedText += chunk.content;
+            try {
+              const partial = JSON.parse(accumulatedText);
+              yield { type: "partial", partial, text: accumulatedText };
+            } catch (e) {
+            }
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      try {
+        const object = JSON.parse(accumulatedText);
+        yield { type: "complete", object, text: accumulatedText };
+      } catch (e) {
+        yield { type: "error", error: new Error("Invalid JSON in response") };
+      }
+    });
+  }
+};
+
+// src/providers/sarvam/sarvam.ts
+var SarvamProvider = class extends BaseProvider {
+  getDefaultBaseUrl() {
+    return "https://api.sarvam.ai/v1";
+  }
+  generateText(request) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const messages = this.formatMessages(request);
+      try {
+        const response = yield this.makeRequest(this.getEndpoint("/chat/completions"), {
+          method: "POST",
+          body: JSON.stringify({
+            model: this.config.model,
+            messages: messages.map((m) => ({
+              role: m.role,
+              content: m.content
+            })),
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            top_p: this.config.topP,
+            stop: this.config.stop
+          })
+        });
+        const data = yield response.json();
+        if (!data.choices || data.choices.length === 0) {
+          throw new ProviderError(
+            "sarvam",
+            "No choices returned from Sarvam API",
+            response.status,
+            { response: data }
+          );
+        }
+        return {
+          text: data.choices[0].message.content,
+          usage: {
+            promptTokens: ((_a = data.usage) == null ? void 0 : _a.prompt_tokens) || 0,
+            completionTokens: ((_b = data.usage) == null ? void 0 : _b.completion_tokens) || 0,
+            totalTokens: ((_c = data.usage) == null ? void 0 : _c.total_tokens) || 0
+          },
+          finishReason: this.mapSarvamFinishReason(data.choices[0].finish_reason)
+        };
+      } catch (error) {
+        throw new ProviderError(
+          "sarvam",
+          error instanceof Error ? error.message : "Unknown error",
+          void 0,
+          { originalError: error }
+        );
+      }
+    });
+  }
+  streamText(request) {
+    return __asyncGenerator(this, null, function* () {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const messages = this.formatMessages(request);
+      try {
+        const response = yield new __await(this.makeRequest(
+          this.getEndpoint("/chat/completions"),
+          {
+            method: "POST",
+            body: JSON.stringify({
+              model: this.config.model,
+              messages: messages.map((m) => ({
+                role: m.role,
+                content: m.content
+              })),
+              max_tokens: this.config.maxTokens,
+              temperature: this.config.temperature,
+              stream: true
+            })
+          },
+          true
+        ));
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = yield new __await(reader.read());
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6);
+              if (data === "[DONE]") continue;
+              try {
+                const parsed = JSON.parse(data);
+                const content = (_c = (_b = (_a = parsed.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.delta) == null ? void 0 : _c.content;
+                if (content) {
+                  yield { type: "content", content };
+                }
+                if ((_e = (_d = parsed.choices) == null ? void 0 : _d[0]) == null ? void 0 : _e.finish_reason) {
+                  yield {
+                    type: "done",
+                    done: {
+                      finishReason: this.mapSarvamFinishReason(parsed.choices[0].finish_reason),
+                      usage: {
+                        promptTokens: ((_f = parsed.usage) == null ? void 0 : _f.prompt_tokens) || 0,
+                        completionTokens: ((_g = parsed.usage) == null ? void 0 : _g.completion_tokens) || 0,
+                        totalTokens: ((_h = parsed.usage) == null ? void 0 : _h.total_tokens) || 0
+                      }
+                    }
+                  };
+                }
+              } catch (e) {
+              }
+            }
+          }
+        }
+      } catch (error) {
+        yield {
+          type: "error",
+          error: new ProviderError(
+            "sarvam",
+            error instanceof Error ? error.message : "Streaming error",
+            void 0,
+            { originalError: error }
+          )
+        };
+      }
+    });
+  }
+  generateObject(request) {
+    return __async(this, null, function* () {
+      const enhancedRequest = __spreadProps(__spreadValues({}, request), {
+        messages: [
+          ...request.messages,
+          {
+            role: "user",
+            content: `Respond with valid JSON matching this schema: ${JSON.stringify(request.schema)}`
+          }
+        ]
+      });
+      const textResponse = yield this.generateText(enhancedRequest);
+      try {
+        const object = JSON.parse(textResponse.text);
+        return {
+          object,
+          text: textResponse.text,
+          usage: textResponse.usage
+        };
+      } catch (error) {
+        throw new ProviderError(
+          "sarvam",
+          `Failed to parse JSON response: ${error instanceof Error ? error.message : "Unknown error"}`,
+          void 0,
+          { responseText: textResponse.text }
+        );
+      }
+    });
+  }
+  streamObject(request) {
+    return __asyncGenerator(this, null, function* () {
+      let accumulatedText = "";
+      try {
+        for (var iter = __forAwait(this.streamText(request)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          if (chunk.type === "content") {
+            accumulatedText += chunk.content;
+            try {
+              const partial = JSON.parse(accumulatedText);
+              yield { type: "partial", partial, text: accumulatedText };
+            } catch (e) {
+            }
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      try {
+        const object = JSON.parse(accumulatedText);
+        yield { type: "complete", object, text: accumulatedText };
+      } catch (e) {
+        yield { type: "error", error: new Error("Invalid JSON in response") };
+      }
+    });
+  }
+  /**
+   * Map Sarvam's finish reason to standard format
+   */
+  mapSarvamFinishReason(reason) {
+    const mapping = {
+      "stop": "stop",
+      "length": "length",
+      "max_tokens": "length",
+      "content_filter": "content_filter"
+    };
+    return mapping[reason] || "stop";
+  }
+};
+
+// src/providers/factory.ts
+function createProvider(config) {
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIProvider(config);
+    case "anthropic":
+      return new AnthropicProvider(config);
+    case "google":
+      return new GoogleProvider(config);
+    case "sarvam":
+      return new SarvamProvider(config);
+    case "custom":
+      return new CustomProvider(config);
+    default:
+      throw new Error(`Unknown extended provider: ${config.provider}`);
+  }
+}
+
+// src/stream/stream-reader.ts
+var TransformStream = class {
+  constructor(transformer) {
+    __publicField(this, "transformer");
+    this.transformer = transformer;
+  }
+  transform(source) {
+    return __asyncGenerator(this, null, function* () {
+      try {
+        for (var iter = __forAwait(source), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const chunk = temp.value;
+          yield yield new __await(this.transformer(chunk));
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+};
+var FlareStreamReader = class {
+  constructor(source) {
+    __publicField(this, "source");
+    __publicField(this, "done", false);
+    this.source = source[Symbol.asyncIterator]();
+  }
+  read() {
+    return __async(this, null, function* () {
+      if (this.done) {
+        return { value: void 0, done: true };
+      }
+      const result = yield this.source.next();
+      this.done = result.done || false;
+      return { value: result.value, done: this.done };
+    });
+  }
+  cancel() {
+    this.done = true;
+    if (this.source.return) {
+      this.source.return();
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return __asyncGenerator(this, null, function* () {
+      while (!this.done) {
+        const { value, done } = yield new __await(this.read());
+        if (done) break;
+        yield value;
+      }
+    });
+  }
+};
+function createDataStreamWriter() {
+  let controller = null;
+  const encoder = new TextEncoder();
+  const readable = new ReadableStream({
+    start(ctrl) {
+      controller = ctrl;
+    },
+    cancel() {
+      controller = null;
+    }
+  });
+  const write = (data) => {
+    if (controller) {
+      controller.enqueue(encoder.encode(data));
+    }
+  };
+  return {
+    readable,
+    /**
+     * Write data event
+     */
+    writeData(data) {
+      write(`data: ${JSON.stringify(data)}
+
+`);
+    },
+    /**
+     * Write error event
+     */
+    writeError(error) {
+      write(`event: error
+data: ${JSON.stringify({
+        message: error.message,
+        code: error.code
+      })}
+
+`);
+    },
+    /**
+     * Write custom event
+     */
+    writeEvent(event, data) {
+      write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+    },
+    /**
+     * Close the stream
+     */
+    close() {
+      if (controller) {
+        controller.close();
+        controller = null;
+      }
+    }
+  };
+}
+function toUiStreamResponse(stream, headers) {
+  const writer = createDataStreamWriter();
+  (() => __async(null, null, function* () {
+    try {
+      try {
+        for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
+          const chunk = temp.value;
+          writer.writeData(chunk);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield temp.call(iter));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+      writer.close();
+    } catch (error2) {
+      writer.writeError(error2 instanceof Error ? error2 : new Error(String(error2)));
+      writer.close();
+    }
+  }))();
+  return new Response(writer.readable, {
+    headers: __spreadValues({
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }, headers)
+  });
+}
+function parseSSEStream(response) {
+  return __asyncGenerator(this, null, function* () {
+    if (!response.body) {
+      throw new StreamError("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = yield new __await(reader.read());
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const match = line.match(/^data: (.+)$/m);
+          if (match) {
+            try {
+              yield JSON.parse(match[1]);
+            } catch (e) {
+              console.error("Failed to parse SSE data:", e);
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+}
+function mergeStreams(...streams) {
+  return __asyncGenerator(this, null, function* () {
+    const iterators = streams.map((s) => s[Symbol.asyncIterator]());
+    const pending = new Set(iterators);
+    while (pending.size > 0) {
+      const results = yield new __await(Promise.race(
+        Array.from(pending).map((it) => __async(null, null, function* () {
+          return { it, result: yield it.next() };
+        }))
+      ));
+      if (results.result.done) {
+        pending.delete(results.it);
+      } else {
+        yield results.result.value;
+      }
+    }
+  });
+}
+function bufferStream(stream, size) {
+  return __asyncGenerator(this, null, function* () {
+    let buffer = [];
+    try {
+      for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+        const item = temp.value;
+        buffer.push(item);
+        if (buffer.length >= size) {
+          yield buffer;
+          buffer = [];
+        }
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    if (buffer.length > 0) {
+      yield buffer;
+    }
+  });
+}
+function throttleStream(stream, delayMs) {
+  return __asyncGenerator(this, null, function* () {
+    try {
+      for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+        const item = temp.value;
+        yield item;
+        yield new __await(new Promise((resolve) => setTimeout(resolve, delayMs)));
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+  });
+}
+
+// src/stream/stream-client.ts
+import EventEmitter3 from "eventemitter3";
+var DEFAULT_CONFIG4 = {
+  maxTokens: 1024,
+  temperature: 0.7,
+  enableQueueing: true,
+  enablePooling: true,
+  enableMetrics: true,
+  retry: {
+    maxRetries: 3,
+    initialDelay: 1e3,
+    maxDelay: 3e4
+  },
+  circuitBreaker: {
+    failureThreshold: 5,
+    resetTimeout: 6e4
+  },
+  rateLimit: {
+    maxRequests: 100,
+    windowMs: 6e4
+  }
+};
+var FlareClient = class extends EventEmitter3 {
+  constructor(config) {
+    super();
+    __publicField(this, "config");
+    __publicField(this, "provider");
+    __publicField(this, "retryHandler");
+    __publicField(this, "circuitBreaker");
+    __publicField(this, "rateLimiter");
+    __publicField(this, "requestQueue");
+    __publicField(this, "metrics");
+    __publicField(this, "startTime", Date.now());
+    this.config = __spreadValues(__spreadValues({}, DEFAULT_CONFIG4), config);
+    this.provider = createProvider(this.config);
+    this.retryHandler = new RetryHandler(this.config.retry);
+    this.circuitBreaker = new CircuitBreaker(this.config.circuitBreaker);
+    this.rateLimiter = new RateLimiter(this.config.rateLimit);
+    this.metrics = new MetricsCollector();
+    if (this.config.enableQueueing) {
+      this.requestQueue = new RequestQueue({
+        concurrency: this.config.poolSize || 10
+      });
+    }
+    this.setupEventListeners();
+  }
+  /**
+   * Setup event listeners for monitoring
+   */
+  setupEventListeners() {
+    this.circuitBreaker.on("open", () => {
+      this.emit("circuit-breaker:open");
+      if (this.config.debug) {
+        console.warn("[FlareClient] Circuit breaker opened");
+      }
+    });
+    this.circuitBreaker.on("close", () => {
+      this.emit("circuit-breaker:close");
+      if (this.config.debug) {
+        console.log("[FlareClient] Circuit breaker closed");
+      }
+    });
+    if (this.requestQueue) {
+      this.requestQueue.on("enqueue", (data) => {
+        this.emit("queue:enqueue", data);
+      });
+      this.requestQueue.on("drain", () => {
+        this.emit("queue:drain");
+      });
+    }
+  }
+  /**
+   * Generate text synchronously
+   * @param request - Text generation request
+   * @returns Generated text response
+   */
+  generateText(request) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const startTime = Date.now();
+      try {
+        yield this.rateLimiter.acquire((_a = this.config.rateLimit) == null ? void 0 : _a.clientId);
+        const execute = () => __async(this, null, function* () {
+          return yield this.circuitBreaker.execute(() => __async(this, null, function* () {
+            const mergedConfig = __spreadValues(__spreadValues({}, this.config), request.config);
+            return yield this.provider.generateText(__spreadProps(__spreadValues({}, request), {
+              config: mergedConfig
+            }));
+          }));
+        });
+        let result;
+        if (this.requestQueue && this.config.enableQueueing) {
+          result = yield this.requestQueue.add(
+            () => this.retryHandler.execute(execute),
+            ((_b = request.config) == null ? void 0 : _b.queuePriority) || 0
+          );
+        } else {
+          result = yield this.retryHandler.execute(execute);
+        }
+        this.metrics.recordSuccess(Date.now() - startTime);
+        this.emit("request:success", { latency: Date.now() - startTime });
+        return result;
+      } catch (error) {
+        this.metrics.recordFailure(Date.now() - startTime);
+        this.emit("request:error", { error, latency: Date.now() - startTime });
+        throw error;
+      }
+    });
+  }
+  /**
+   * Stream text generation
+   * @param request - Text generation request
+   * @returns Async iterable of text chunks
+   */
+  streamText(request) {
+    return __asyncGenerator(this, null, function* () {
+      var _a;
+      const startTime = Date.now();
+      try {
+        yield new __await(this.rateLimiter.acquire((_a = this.config.rateLimit) == null ? void 0 : _a.clientId));
+        const stream = this.provider.streamText(request);
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const chunk = temp.value;
+            yield chunk;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        this.metrics.recordSuccess(Date.now() - startTime);
+        this.emit("request:success", { latency: Date.now() - startTime, streaming: true });
+      } catch (error2) {
+        this.metrics.recordFailure(Date.now() - startTime);
+        this.emit("request:error", { error: error2, latency: Date.now() - startTime, streaming: true });
+        throw error2;
+      }
+    });
+  }
+  /**
+   * Generate structured object
+   * @param request - Object generation request
+   * @returns Generated object response
+   */
+  generateObject(request) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const startTime = Date.now();
+      try {
+        yield this.rateLimiter.acquire((_a = this.config.rateLimit) == null ? void 0 : _a.clientId);
+        const execute = () => __async(this, null, function* () {
+          return yield this.circuitBreaker.execute(() => __async(this, null, function* () {
+            return yield this.provider.generateObject(request);
+          }));
+        });
+        let result;
+        if (this.requestQueue && this.config.enableQueueing) {
+          result = yield this.requestQueue.add(
+            () => this.retryHandler.execute(execute),
+            ((_b = request.config) == null ? void 0 : _b.queuePriority) || 0
+          );
+        } else {
+          result = yield this.retryHandler.execute(execute);
+        }
+        this.metrics.recordSuccess(Date.now() - startTime);
+        return result;
+      } catch (error) {
+        this.metrics.recordFailure(Date.now() - startTime);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Stream object generation
+   * @param request - Object generation request
+   * @returns Async iterable of object chunks
+   */
+  streamObject(request) {
+    return __asyncGenerator(this, null, function* () {
+      var _a;
+      const startTime = Date.now();
+      try {
+        yield new __await(this.rateLimiter.acquire((_a = this.config.rateLimit) == null ? void 0 : _a.clientId));
+        const stream = this.provider.streamObject(request);
+        try {
+          for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+            const chunk = temp.value;
+            yield chunk;
+          }
+        } catch (temp) {
+          error = [temp];
+        } finally {
+          try {
+            more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+          } finally {
+            if (error)
+              throw error[0];
+          }
+        }
+        this.metrics.recordSuccess(Date.now() - startTime);
+      } catch (error2) {
+        this.metrics.recordFailure(Date.now() - startTime);
+        throw error2;
+      }
+    });
+  }
+  /**
+   * Get health status
+   */
+  getHealth() {
+    var _a, _b;
+    const metrics = this.metrics.getMetrics();
+    let status = "healthy";
+    if (this.circuitBreaker.getState() === "open") {
+      status = "unhealthy";
+    } else if (metrics.failedRequests > metrics.successfulRequests * 0.1) {
+      status = "degraded";
+    }
+    return {
+      status,
+      timestamp: Date.now(),
+      uptime: Date.now() - this.startTime,
+      circuitBreaker: this.circuitBreaker.getState(),
+      activeConnections: (_a = this.requestQueue) == null ? void 0 : _a.getRunning(),
+      queueSize: (_b = this.requestQueue) == null ? void 0 : _b.size(),
+      metrics
+    };
+  }
+  /**
+   * Get performance metrics
+   */
+  getMetrics() {
+    return this.metrics.getDetailedStats();
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.config = __spreadValues(__spreadValues({}, this.config), config);
+    if (config.retry) {
+      this.retryHandler.updateConfig(config.retry);
+    }
+    if (config.rateLimit) {
+      this.rateLimiter = new RateLimiter(config.rateLimit);
+    }
+  }
+  /**
+   * Reset circuit breaker
+   */
+  resetCircuitBreaker() {
+    this.circuitBreaker.reset();
+  }
+  /**
+   * Clean up resources
+   */
+  destroy() {
+    this.circuitBreaker.destroy();
+    this.rateLimiter.destroy();
+    if (this.requestQueue) {
+      this.requestQueue.clear();
+    }
+    this.removeAllListeners();
+  }
+};
+function createFlareClient(config) {
+  return new FlareClient(config);
+}
+export {
+  AnthropicProvider,
+  AuthenticationError,
+  BaseProvider,
+  CircuitBreaker,
+  CircuitBreakerError,
+  CircuitState,
+  ContentFilterError,
+  CustomProvider,
+  FlareClient,
+  FlareError,
+  FlareStreamReader,
+  GoogleProvider,
+  MetricsCollector,
+  NetworkError,
+  OpenAIProvider,
+  ParseError,
+  ProviderError,
+  RateLimitError,
+  RateLimiter,
+  RequestQueue,
+  RetryHandler,
+  SarvamProvider,
+  StreamError,
+  TimeoutError,
+  TransformStream,
+  ValidationError,
+  bufferStream,
+  createCircuitBreaker,
+  createDataStreamWriter,
+  createFlareClient,
+  createMetricsCollector,
+  createProvider,
+  createRateLimiter,
+  createRequestQueue,
+  createRetryHandler,
+  getErrorStatusCode,
+  getGlobalMetrics,
+  isRetryableError,
+  measureLatency,
+  mergeStreams,
+  parseSSEStream,
+  throttleStream,
+  toUiStreamResponse,
+  withRetry
+};
+//# sourceMappingURL=index.mjs.map