@umituz/web-ai 0.0.0-stage → 1.0.0

package/dist/core/index.js

@@ -0,0 +1,969 @@
+// src/core/tiers/index.ts
+var TEXT_TIERS = ["fast", "balanced", "powerful"];
+function isTextTier(value) {
+  return typeof value === "string" && TEXT_TIERS.includes(value);
+}
+function resolveModel(tiers, tier, providerId) {
+  const model = tiers[tier] ?? tiers.balanced;
+  if (!model) {
+    throw new Error(
+      `${providerId} has no model configured for tier "${tier}" \u2014 pass an explicit model or configure the tier map`
+    );
+  }
+  return model;
+}
+function mergeTierOverrides(defaults, overrides) {
+  if (!overrides) return defaults;
+  return { ...defaults, ...overrides };
+}
+
+// src/core/errors/ai-error-types.ts
+var AIErrorType = /* @__PURE__ */ ((AIErrorType2) => {
+  AIErrorType2["INVALID_API_KEY"] = "INVALID_API_KEY";
+  AIErrorType2["MISSING_CONFIG"] = "MISSING_CONFIG";
+  AIErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  AIErrorType2["ABORT_ERROR"] = "ABORT_ERROR";
+  AIErrorType2["RATE_LIMIT_ERROR"] = "RATE_LIMIT_ERROR";
+  AIErrorType2["SERVER_ERROR"] = "SERVER_ERROR";
+  AIErrorType2["CLIENT_ERROR"] = "CLIENT_ERROR";
+  AIErrorType2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return AIErrorType2;
+})(AIErrorType || {});
+var USER_FRIENDLY_ERROR_MESSAGES = {
+  ["INVALID_API_KEY" /* INVALID_API_KEY */]: "Please check your API key and try again.",
+  ["MISSING_CONFIG" /* MISSING_CONFIG */]: "The provider is not configured. Please create a provider with createAI first.",
+  ["NETWORK_ERROR" /* NETWORK_ERROR */]: "Network error. Please check your connection and try again.",
+  ["ABORT_ERROR" /* ABORT_ERROR */]: "Request was cancelled.",
+  ["RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */]: "You've reached the rate limit. Please wait a moment and try again.",
+  ["SERVER_ERROR" /* SERVER_ERROR */]: "The AI service is temporarily unavailable. Please try again later.",
+  ["CLIENT_ERROR" /* CLIENT_ERROR */]: "The request was invalid. Please check your input and try again.",
+  ["UNKNOWN_ERROR" /* UNKNOWN_ERROR */]: "An unexpected error occurred. Please try again."
+};
+
+// src/core/errors/ai-error.ts
+var AIError = class extends Error {
+  type;
+  cause;
+  metadata;
+  constructor(type, message, cause, metadata = {}) {
+    super(message);
+    this.name = "AIError";
+    this.type = type;
+    this.cause = cause;
+    this.metadata = metadata;
+  }
+  toString() {
+    const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
+    return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      message: this.message,
+      metadata: this.metadata
+    };
+  }
+};
+
+// src/core/errors/error-classifier.ts
+var DEFAULT_RETRYABLE_TYPES = /* @__PURE__ */ new Set([
+  "NETWORK_ERROR" /* NETWORK_ERROR */,
+  "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */,
+  "SERVER_ERROR" /* SERVER_ERROR */
+]);
+var DEFAULT_AUTH_TYPES = /* @__PURE__ */ new Set([
+  "INVALID_API_KEY" /* INVALID_API_KEY */
+]);
+var DEFAULT_ERROR_CLASSIFICATION_RULE = {
+  retryable: DEFAULT_RETRYABLE_TYPES,
+  auth: DEFAULT_AUTH_TYPES
+};
+function isRetryableErrorType(type, rule = DEFAULT_ERROR_CLASSIFICATION_RULE) {
+  return rule.retryable.has(type);
+}
+function isAuthErrorType(type, rule = DEFAULT_ERROR_CLASSIFICATION_RULE) {
+  return rule.auth.has(type);
+}
+
+// src/core/errors/http-status-classifier.ts
+var DEFAULT_HTTP_STATUS_RULE = {
+  unauthorizedStatuses: /* @__PURE__ */ new Set([401, 403]),
+  rateLimitedStatus: 429,
+  serverErrorThreshold: 500,
+  clientErrorThreshold: 400
+};
+function classifyHttpStatus(status, rule = DEFAULT_HTTP_STATUS_RULE) {
+  if (rule.unauthorizedStatuses.has(status)) return "INVALID_API_KEY" /* INVALID_API_KEY */;
+  if (status === rule.rateLimitedStatus) return "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */;
+  if (status >= rule.serverErrorThreshold) return "SERVER_ERROR" /* SERVER_ERROR */;
+  if (status >= rule.clientErrorThreshold) return "CLIENT_ERROR" /* CLIENT_ERROR */;
+  return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+}
+
+// src/core/errors/user-friendly-error-resolver.ts
+var KEYWORD_FALLBACK_RULES = [
+  { keywords: ["api key", "unauthorized"], type: "INVALID_API_KEY" /* INVALID_API_KEY */ },
+  { keywords: ["rate limit"], type: "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ },
+  { keywords: ["network", "fetch"], type: "NETWORK_ERROR" /* NETWORK_ERROR */ },
+  { keywords: ["abort"], type: "ABORT_ERROR" /* ABORT_ERROR */ }
+];
+function resolveUserFriendlyErrorMessage(error) {
+  if (error instanceof AIError) {
+    return USER_FRIENDLY_ERROR_MESSAGES[error.type];
+  }
+  if (error instanceof Error) {
+    const lower = error.message.toLowerCase();
+    for (const rule of KEYWORD_FALLBACK_RULES) {
+      if (rule.keywords.some((kw) => lower.includes(kw))) {
+        return USER_FRIENDLY_ERROR_MESSAGES[rule.type];
+      }
+    }
+    if (error.message.length > 0) return error.message;
+  }
+  return USER_FRIENDLY_ERROR_MESSAGES["UNKNOWN_ERROR" /* UNKNOWN_ERROR */];
+}
+
+// src/core/errors/error-resolver.ts
+var resolveUserFriendlyMessage = resolveUserFriendlyErrorMessage;
+function formatErrorForLogging(error) {
+  if (error instanceof AIError) {
+    return {
+      message: error.message,
+      type: error.type,
+      stack: error.stack,
+      metadata: error.metadata
+    };
+  }
+  if (error instanceof Error) {
+    return { message: error.message, type: error.name, stack: error.stack };
+  }
+  return { message: String(error), type: typeof error };
+}
+
+// src/core/errors/response-error-message-extractor.ts
+function extractErrorMessageFromJsonBody(body) {
+  if (!body || typeof body !== "object") return null;
+  const candidate = body;
+  const message = candidate.error?.message ?? candidate.message;
+  if (typeof message === "string" && message.length > 0) return message;
+  return null;
+}
+function buildHttpStatusFallback(status, statusText) {
+  const trimmedStatusText = statusText.trim();
+  if (trimmedStatusText.length > 0) {
+    return `HTTP ${status}: ${trimmedStatusText}`;
+  }
+  return `HTTP ${status}`;
+}
+async function extractErrorMessageFromResponse(response) {
+  const body = await response.json().catch(() => null);
+  const fromBody = extractErrorMessageFromJsonBody(body);
+  if (fromBody) return fromBody;
+  return buildHttpStatusFallback(response.status, response.statusText);
+}
+function describeAIErrorType(type) {
+  return `AIError[${type}]`;
+}
+
+// src/core/executor/retry-executor.strategy.ts
+var RetryExecutor = class {
+  constructor(retryManager2, options) {
+    this.retryManager = retryManager2;
+    this.options = options;
+  }
+  retryManager;
+  options;
+  execute(fn, ...args) {
+    return this.retryManager.execute(() => fn(...args), this.options);
+  }
+};
+
+// src/core/executor/queue-executor.strategy.ts
+var QueueExecutor = class {
+  constructor(queue, priority) {
+    this.queue = queue;
+    this.priority = priority;
+  }
+  queue;
+  priority;
+  execute(fn, ...args) {
+    return this.queue.add(() => fn(...args), this.priority);
+  }
+};
+
+// src/core/executor/dedupe-executor.strategy.ts
+var DedupeExecutor = class {
+  constructor(deduplicator, options) {
+    this.deduplicator = deduplicator;
+    this.options = options;
+  }
+  deduplicator;
+  options;
+  execute(fn, ...args) {
+    const key = this.options.generateKey(...args);
+    return this.deduplicator.execute(key, () => fn(...args));
+  }
+};
+
+// src/core/executor/composite-executor.strategy.ts
+var CompositeExecutor = class {
+  executors;
+  constructor(executors) {
+    this.executors = executors;
+  }
+  execute(fn, ...args) {
+    const composed = this.compress(fn);
+    return composed(...args);
+  }
+  compress(fn) {
+    return this.executors.reduceRight(
+      (innerFn, executor) => (...a) => executor.execute(innerFn, ...a),
+      fn
+    );
+  }
+};
+
+// src/core/calculations/lru-key-selector.ts
+function selectLeastRecentlyUsedKey(entries) {
+  let oldestKey = null;
+  let oldestAccess = Number.POSITIVE_INFINITY;
+  for (const [key, entry] of entries.entries()) {
+    if (entry.lastAccess < oldestAccess) {
+      oldestAccess = entry.lastAccess;
+      oldestKey = key;
+    }
+  }
+  return oldestKey;
+}
+
+// src/core/calculations/cache-hit-rate.ts
+function calculateCacheHitRate(entries) {
+  if (entries.length === 0) return 0;
+  const totalAccess = entries.reduce((sum, e) => sum + e.accessCount, 0);
+  return totalAccess / entries.length;
+}
+
+// src/core/utils/cache-key-builder.ts
+function buildCacheKey(params) {
+  const sortedKeys = Object.keys(params).sort();
+  const sortedParams = {};
+  for (const key of sortedKeys) {
+    sortedParams[key] = params[key];
+  }
+  return JSON.stringify(sortedParams);
+}
+
+// src/core/utils/cache-manager.ts
+var DEFAULT_CACHE_MAX_SIZE = 100;
+var DEFAULT_CACHE_TTL_MS = 3e5;
+var CacheManager = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  ttl;
+  constructor(options = {}) {
+    this.maxSize = options.maxSize ?? DEFAULT_CACHE_MAX_SIZE;
+    this.ttl = options.ttl ?? DEFAULT_CACHE_TTL_MS;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (this.isExpired(entry)) {
+      this.cache.delete(key);
+      return null;
+    }
+    entry.accessCount += 1;
+    entry.lastAccess = Date.now();
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const lruKey = selectLeastRecentlyUsedKey(this.cache);
+      if (lruKey !== null) this.cache.delete(lruKey);
+    }
+    this.cache.set(key, {
+      value,
+      timestamp: Date.now(),
+      accessCount: 1,
+      lastAccess: Date.now()
+    });
+  }
+  has(key) {
+    const entry = this.cache.get(key);
+    return entry !== void 0 && !this.isExpired(entry);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  generateKey(params) {
+    return buildCacheKey(params);
+  }
+  getStats() {
+    const now = Date.now();
+    const entries = Array.from(this.cache.entries()).map(([key, entry]) => ({
+      key,
+      accessCount: entry.accessCount,
+      ageMs: now - entry.timestamp
+    }));
+    const hitRate = calculateCacheHitRate(
+      Array.from(this.cache.values()).map((e) => ({ accessCount: e.accessCount }))
+    );
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize,
+      hitRate,
+      entries
+    };
+  }
+  isExpired(entry) {
+    return Date.now() - entry.timestamp > this.ttl;
+  }
+};
+var cacheManager = new CacheManager();
+
+// src/core/calculations/exponential-backoff.ts
+function calculateExponentialBackoff(params) {
+  const {
+    attempt,
+    initialDelay,
+    maxDelay,
+    backoffMultiplier,
+    jitterFactor,
+    random = Math.random
+  } = params;
+  const base = initialDelay * Math.pow(backoffMultiplier, Math.max(0, attempt - 1));
+  const capped = Math.min(base, maxDelay);
+  const jitterMultiplier = random() * 2 - 1;
+  const jitter = capped * jitterFactor * jitterMultiplier;
+  return Math.max(0, capped + jitter);
+}
+
+// src/core/constants/identifier.constants.ts
+var DEFAULT_RETRY_MAX_ATTEMPTS = 3;
+var DEFAULT_RETRY_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_RETRY_MAX_DELAY_MS = 1e4;
+var DEFAULT_RETRY_BACKOFF_MULTIPLIER = 2;
+var DEFAULT_RETRY_JITTER_FACTOR = 0.1;
+
+// src/core/utils/retry.ts
+var RETRYABLE_MESSAGE_KEYWORDS = [
+  "network",
+  "timeout",
+  "econnrefused",
+  "enotfound",
+  "etimedout"
+];
+var RetryManager = class {
+  defaults;
+  constructor() {
+    this.defaults = {
+      maxAttempts: DEFAULT_RETRY_MAX_ATTEMPTS,
+      initialDelay: DEFAULT_RETRY_INITIAL_DELAY_MS,
+      maxDelay: DEFAULT_RETRY_MAX_DELAY_MS,
+      backoffMultiplier: DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+      jitterFactor: DEFAULT_RETRY_JITTER_FACTOR
+    };
+  }
+  async execute(fn, options = {}) {
+    const maxAttempts = options.maxAttempts ?? this.defaults.maxAttempts;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt >= maxAttempts || !this.shouldRetry(lastError, options)) {
+          throw lastError;
+        }
+        const delay = calculateExponentialBackoff({
+          attempt,
+          initialDelay: options.initialDelay ?? this.defaults.initialDelay,
+          maxDelay: options.maxDelay ?? this.defaults.maxDelay,
+          backoffMultiplier: options.backoffMultiplier ?? this.defaults.backoffMultiplier,
+          jitterFactor: options.jitterFactor ?? this.defaults.jitterFactor
+        });
+        await this.delay(delay);
+      }
+    }
+    throw lastError ?? new Error("Retry loop exited without result");
+  }
+  shouldRetry(error, options) {
+    if (options.shouldRetry) return options.shouldRetry(error);
+    if (error instanceof AIError) {
+      return isRetryableErrorType(error.type, DEFAULT_ERROR_CLASSIFICATION_RULE);
+    }
+    const lower = error.message.toLowerCase();
+    return RETRYABLE_MESSAGE_KEYWORDS.some((kw) => lower.includes(kw));
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var retryManager = new RetryManager();
+async function withRetry(fn, options) {
+  return retryManager.execute(fn, options);
+}
+
+// src/core/utils/request-queue.util.ts
+var DEFAULT_MAX_CONCURRENT = 3;
+var DEFAULT_PRIORITY = 0;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var RequestQueue = class {
+  queue = [];
+  activeRequests = /* @__PURE__ */ new Set();
+  maxConcurrent;
+  defaultPriority;
+  requestTimeout;
+  requestIdCounter = 0;
+  constructor(options = {}) {
+    this.maxConcurrent = options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this.defaultPriority = options.defaultPriority ?? DEFAULT_PRIORITY;
+    this.requestTimeout = options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  }
+  add(requestFn, priority) {
+    return new Promise((resolve, reject) => {
+      const id = `req-${++this.requestIdCounter}`;
+      const queuedRequest = {
+        id,
+        priority: priority ?? this.defaultPriority,
+        requestFn,
+        resolve,
+        reject,
+        timestamp: Date.now()
+      };
+      this.queue.push(queuedRequest);
+      this.sortQueue();
+      this.process();
+    });
+  }
+  cancelAll() {
+    for (const request of this.queue) {
+      request.reject(new Error("Request was cancelled"));
+    }
+    this.queue = [];
+  }
+  sortQueue() {
+    this.queue.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.timestamp - b.timestamp;
+    });
+  }
+  process() {
+    while (this.queue.length > 0 && this.activeRequests.size < this.maxConcurrent) {
+      const request = this.queue.shift();
+      if (!request) break;
+      this.executeRequest(request);
+    }
+  }
+  executeRequest(request) {
+    this.activeRequests.add(request.id);
+    const timeoutId = setTimeout(() => {
+      this.activeRequests.delete(request.id);
+      request.reject(new Error(`Request ${request.id} timed out`));
+      this.process();
+    }, this.requestTimeout);
+    request.requestFn().then((result) => {
+      clearTimeout(timeoutId);
+      request.resolve(result);
+    }).catch((error) => {
+      clearTimeout(timeoutId);
+      request.reject(error);
+    }).finally(() => {
+      this.activeRequests.delete(request.id);
+      this.process();
+    });
+  }
+};
+var requestQueue = new RequestQueue();
+
+// src/core/utils/request-deduplicator.util.ts
+var DEFAULT_DEDUPE_TTL_MS = 3e4;
+var RequestDeduplicator = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_DEDUPE_TTL_MS) {
+    this.ttl = ttl;
+  }
+  execute(key, requestFn) {
+    this.cleanup();
+    const existing = this.pendingRequests.get(key);
+    if (existing) {
+      return existing.promise;
+    }
+    const promise = requestFn();
+    this.pendingRequests.set(key, {
+      promise,
+      timestamp: Date.now()
+    });
+    promise.catch(() => void 0).then(() => {
+      this.pendingRequests.delete(key);
+    });
+    return promise;
+  }
+  cancelAll() {
+    this.pendingRequests.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, request] of this.pendingRequests.entries()) {
+      if (now - request.timestamp > this.ttl) {
+        this.pendingRequests.delete(key);
+      }
+    }
+  }
+};
+var requestDeduplicator = new RequestDeduplicator();
+
+// src/core/calculations/timing-window.ts
+function shouldCallOnLeadingEdge(params) {
+  const { now, lastCallTime, interval, leadingEnabled, isThrottled } = params;
+  if (!leadingEnabled) return false;
+  if (isThrottled) return false;
+  return now - lastCallTime >= interval;
+}
+function calculateTrailingDelay(params) {
+  return Math.max(0, params.interval - params.timeSinceLastCall);
+}
+
+// src/core/utils/debounce.ts
+var DEFAULT_DEBOUNCE_DELAY_MS = 300;
+var DEFAULT_THROTTLE_INTERVAL_MS = 1e3;
+var DebounceManager = class {
+  timers = /* @__PURE__ */ new Map();
+  lastArgs = /* @__PURE__ */ new Map();
+  debounce(fn, options = {}) {
+    const delay = options.delay ?? DEFAULT_DEBOUNCE_DELAY_MS;
+    const leading = options.leading ?? false;
+    const trailing = options.trailing ?? true;
+    let timer = null;
+    let lastCallTime = 0;
+    let lastResult;
+    return ((...args) => {
+      const now = Date.now();
+      const shouldCallLeading = shouldCallOnLeadingEdge({
+        now,
+        lastCallTime,
+        interval: delay,
+        leadingEnabled: leading,
+        isThrottled: timer !== null
+      });
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (shouldCallLeading) {
+        lastCallTime = now;
+        lastResult = fn(...args);
+        return lastResult;
+      }
+      if (trailing) {
+        timer = setTimeout(() => {
+          timer = null;
+          lastCallTime = Date.now();
+          lastResult = fn(...args);
+        }, delay);
+      }
+      return lastResult;
+    });
+  }
+  debounceByKey(key, fn, delay = DEFAULT_DEBOUNCE_DELAY_MS) {
+    return ((...args) => {
+      this.lastArgs.set(key, args);
+      const existingTimer = this.timers.get(key);
+      if (existingTimer) clearTimeout(existingTimer);
+      const timer = setTimeout(() => {
+        this.timers.delete(key);
+        const pendingArgs = this.lastArgs.get(key);
+        this.lastArgs.delete(key);
+        if (pendingArgs) fn(...pendingArgs);
+      }, delay);
+      this.timers.set(key, timer);
+    });
+  }
+  cancelDebounce(key) {
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+    this.lastArgs.delete(key);
+  }
+  flushDebounce(key, fn) {
+    this.cancelDebounce(key);
+    const args = this.lastArgs.get(key);
+    if (args) {
+      fn(...args);
+      this.lastArgs.delete(key);
+    }
+  }
+};
+var ThrottleManager = class {
+  timers = /* @__PURE__ */ new Map();
+  lastArgs = /* @__PURE__ */ new Map();
+  throttle(fn, options = {}) {
+    const interval = options.interval ?? DEFAULT_THROTTLE_INTERVAL_MS;
+    const leading = options.leading ?? true;
+    const trailing = options.trailing ?? false;
+    let timer = null;
+    let lastCallTime = 0;
+    let lastResult;
+    let pendingArgs = null;
+    return ((...args) => {
+      const now = Date.now();
+      const timeSinceLastCall = now - lastCallTime;
+      const shouldCall = shouldCallOnLeadingEdge({
+        now,
+        lastCallTime,
+        interval,
+        leadingEnabled: leading,
+        isThrottled: timer !== null
+      });
+      pendingArgs = args;
+      if (shouldCall) {
+        lastCallTime = now;
+        lastResult = fn(...args);
+        return lastResult;
+      }
+      if (trailing && !timer) {
+        const delay = calculateTrailingDelay({ interval, timeSinceLastCall });
+        timer = setTimeout(() => {
+          timer = null;
+          lastCallTime = Date.now();
+          if (pendingArgs) {
+            lastResult = fn(...pendingArgs);
+            pendingArgs = null;
+          }
+        }, delay);
+      }
+      return lastResult;
+    });
+  }
+  throttleByKey(key, fn, interval = DEFAULT_THROTTLE_INTERVAL_MS) {
+    return ((...args) => {
+      const existingTimer = this.timers.get(key);
+      if (existingTimer) {
+        this.lastArgs.set(key, args);
+        return;
+      }
+      fn(...args);
+      const timer = setTimeout(() => {
+        this.timers.delete(key);
+        const pendingArgs = this.lastArgs.get(key);
+        if (pendingArgs) {
+          this.lastArgs.delete(key);
+          fn(...pendingArgs);
+          const nextTimer = setTimeout(() => {
+            this.timers.delete(key);
+          }, interval);
+          this.timers.set(key, nextTimer);
+        }
+      }, interval);
+      this.timers.set(key, timer);
+    });
+  }
+  cancelThrottle(key) {
+    const timer = this.timers.get(key);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(key);
+    }
+    this.lastArgs.delete(key);
+  }
+  isThrottled(key) {
+    return this.timers.has(key);
+  }
+};
+var debounceManager = new DebounceManager();
+var throttleManager = new ThrottleManager();
+function debounce(fn, delay) {
+  return debounceManager.debounce(fn, { delay });
+}
+function throttle(fn, interval) {
+  return throttleManager.throttle(fn, { interval });
+}
+
+// src/core/utils/api-key-validator.ts
+var DEFAULT_API_KEY_RULE = {
+  minLength: 10
+};
+function isValidApiKey(apiKey, rule = DEFAULT_API_KEY_RULE) {
+  if (!apiKey) return false;
+  return apiKey.trim().length >= rule.minLength;
+}
+function validateApiKey(apiKey, rule = DEFAULT_API_KEY_RULE) {
+  if (!apiKey) {
+    return { valid: false, reason: "API key is required" };
+  }
+  const trimmed = apiKey.trim();
+  if (trimmed.length === 0) {
+    return { valid: false, reason: "API key cannot be empty" };
+  }
+  if (trimmed.length < rule.minLength) {
+    return {
+      valid: false,
+      reason: `API key must be at least ${rule.minLength} characters`
+    };
+  }
+  return { valid: true };
+}
+
+// src/core/utils/coercion.util.ts
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+  return value;
+}
+function asStringArray(value, max) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).slice(0, max);
+}
+function asObjectArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry)
+  );
+}
+function asTrimmedOptionalString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function clampScore(value, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+function oneOfCatalog(catalog, value) {
+  return catalog.includes(value) ? value : null;
+}
+
+// src/core/constants/protocol.constants.ts
+var SSE_PREFIX = "data: ";
+var SSE_DONE_MARKER = "[DONE]";
+var JSON_CODE_BLOCK_PATTERN = /```json\n([\s\S]*?)\n```/;
+var JSON_OBJECT_PATTERN = /\{[\s\S]*\}/;
+
+// src/core/parsers/sse-lines.ts
+function isSseDataLine(line) {
+  return line.startsWith(SSE_PREFIX);
+}
+function extractSseDataPayload(line) {
+  return line.slice(SSE_PREFIX.length);
+}
+function isSseDoneMarker(payload) {
+  return payload === SSE_DONE_MARKER;
+}
+function splitSseLines(rawChunk) {
+  return rawChunk.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+}
+function normalizeSseChunk(rawChunk) {
+  const lines = splitSseLines(rawChunk);
+  const result = [];
+  for (const line of lines) {
+    if (!isSseDataLine(line)) continue;
+    const payload = extractSseDataPayload(line);
+    result.push({ payload, isDone: isSseDoneMarker(payload) });
+  }
+  return result;
+}
+
+// src/core/parsers/streaming-response.parser.ts
+var StreamingResponseParser = class {
+  constructor(callbacks, extractDelta) {
+    this.callbacks = callbacks;
+    this.extractDelta = extractDelta;
+  }
+  callbacks;
+  extractDelta;
+  decoder = new TextDecoder();
+  async parse(stream) {
+    const reader = stream.getReader();
+    const contentChunks = [];
+    let buffer = "";
+    const consumeLine = (rawLine) => {
+      const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+      const trimmed = line.trim();
+      if (trimmed.length === 0 || !isSseDataLine(trimmed)) return;
+      const payload = extractSseDataPayload(trimmed);
+      if (isSseDoneMarker(payload)) return;
+      const content = this.extractDelta(payload);
+      if (content !== null) {
+        contentChunks.push(content);
+        this.callbacks.onChunk(content);
+      }
+    };
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += this.decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) consumeLine(line);
+      }
+      buffer += this.decoder.decode();
+      if (buffer.length > 0) consumeLine(buffer);
+    } catch (error) {
+      if (error instanceof AIError) throw error;
+      throw new AIError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Stream was interrupted",
+        error instanceof Error ? error : void 0
+      );
+    } finally {
+      reader.releaseLock();
+    }
+    return contentChunks.join("");
+  }
+};
+
+// src/core/parsers/json-content-extractor.ts
+function extractJsonFromCodeFence(content) {
+  const match = content.match(JSON_CODE_BLOCK_PATTERN);
+  if (match && match[1]) return match[1];
+  return null;
+}
+function extractJsonObject(content) {
+  const match = content.match(JSON_OBJECT_PATTERN);
+  if (match && match[0]) return match[0];
+  return null;
+}
+function extractJsonCandidate(content) {
+  return extractJsonFromCodeFence(content) ?? extractJsonObject(content) ?? content;
+}
+
+// src/core/parsers/json-response.parser.ts
+var JsonResponseParser = class {
+  parse(rawContent) {
+    const candidate = extractJsonCandidate(rawContent);
+    try {
+      return JSON.parse(candidate);
+    } catch (error) {
+      throw new AIError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "Failed to parse structured response as JSON",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+
+// src/core/parsers/structured-prompt.builder.ts
+var StructuredPromptBuilder = class _StructuredPromptBuilder {
+  schema;
+  request;
+  constructor(request) {
+    this.request = request;
+  }
+  static for(request) {
+    return new _StructuredPromptBuilder(request);
+  }
+  withSchema(schema) {
+    this.schema = schema;
+    return this;
+  }
+  build() {
+    const schemaSection = this.schema ? `Expected JSON schema:
+${JSON.stringify(this.schema, null, 2)}
+
+` : "";
+    return "Please generate a JSON response for the following request.\n\n" + schemaSection + `Request:
+${this.request}
+
+Respond only with valid JSON, formatted as:
+\`\`\`json
+{...}
+\`\`\``;
+  }
+};
+
+// src/core/sse/sse-response.service.ts
+var SSE_BRIDGE_EVENTS = {
+  delta: "delta",
+  done: "done",
+  error: "error"
+};
+function createSseResponse(openUpstream, options) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      let closed = false;
+      const emit = (event, data) => {
+        if (closed) return;
+        try {
+          controller.enqueue(
+            encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`)
+          );
+        } catch {
+          closed = true;
+        }
+      };
+      const finish = () => {
+        if (closed) return;
+        closed = true;
+        try {
+          controller.close();
+        } catch {
+          closed = true;
+        }
+      };
+      let delivered = false;
+      const consumeLine = (line) => {
+        const trimmed = line.trim();
+        if (!isSseDataLine(trimmed)) return false;
+        const payload = extractSseDataPayload(trimmed);
+        if (isSseDoneMarker(payload)) return true;
+        const text = options.extractDelta(payload);
+        if (text) {
+          delivered = true;
+          emit(SSE_BRIDGE_EVENTS.delta, { text });
+        }
+        return false;
+      };
+      try {
+        const upstream = await openUpstream();
+        const reader = upstream.getReader();
+        let buffer = "";
+        let finished = false;
+        while (!finished) {
+          const { value, done: readerDone } = await reader.read();
+          if (readerDone) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            finished = consumeLine(line);
+            if (finished) break;
+          }
+        }
+        if (!finished && buffer.length > 0) consumeLine(buffer);
+        emit(SSE_BRIDGE_EVENTS.done, options.donePayload);
+        finish();
+      } catch (err) {
+        if (!delivered && options.onStreamFailure) {
+          await options.onStreamFailure(err);
+        }
+        emit(SSE_BRIDGE_EVENTS.error, { code: options.errorCode(err) });
+        finish();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache, no-transform",
+      "x-accel-buffering": "no"
+    }
+  });
+}
+
+export { AIError, AIErrorType, CacheManager, CompositeExecutor, DEFAULT_API_KEY_RULE, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_HTTP_STATUS_RULE, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, DedupeExecutor, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, QueueExecutor, RequestDeduplicator, RequestQueue, RetryExecutor, RetryManager, SSE_BRIDGE_EVENTS, SSE_DONE_MARKER, SSE_PREFIX, StreamingResponseParser, StructuredPromptBuilder, TEXT_TIERS, ThrottleManager, USER_FRIENDLY_ERROR_MESSAGES, asObjectArray, asRecord, asStringArray, asTrimmedOptionalString, buildCacheKey, buildHttpStatusFallback, cacheManager, clampScore, classifyHttpStatus, createSseResponse, debounce, debounceManager, describeAIErrorType, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, formatErrorForLogging, isAuthErrorType, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTextTier, isValidApiKey, mergeTierOverrides, normalizeSseChunk, oneOfCatalog, requestDeduplicator, requestQueue, resolveModel, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, retryManager, splitSseLines, throttle, throttleManager, validateApiKey, withRetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map