@umituz/web-ai 0.0.0-stage → 1.0.1

package/dist/index.js

@@ -0,0 +1,3197 @@
+// 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 KNOWN_ERROR_TYPES = new Set(Object.values(AIErrorType));
+function mapCodeToType(code) {
+  switch (code) {
+    case "VALIDATION_ERROR":
+    case "CLIENT_ERROR":
+      return "CLIENT_ERROR" /* CLIENT_ERROR */;
+    case "INVALID_API_KEY":
+      return "INVALID_API_KEY" /* INVALID_API_KEY */;
+    case "MISSING_CONFIG":
+    case "PROVIDER_UNAVAILABLE":
+      return "MISSING_CONFIG" /* MISSING_CONFIG */;
+    case "PROVIDER_QUOTA_EXHAUSTED":
+    case "RATE_LIMIT_ERROR":
+      return "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */;
+    case "NETWORK_ERROR":
+    case "TIMEOUT":
+      return "NETWORK_ERROR" /* NETWORK_ERROR */;
+    case "ABORT_ERROR":
+    case "ABORTED":
+      return "ABORT_ERROR" /* ABORT_ERROR */;
+    case "SERVER_ERROR":
+    case "PROVIDER_ERROR":
+    case "NO_RESULT":
+      return "SERVER_ERROR" /* SERVER_ERROR */;
+    default:
+      return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+}
+function mapMessageToCode(message, fallback = "UNKNOWN") {
+  const lower = message.toLowerCase();
+  if (lower.includes("validation")) return "VALIDATION_ERROR";
+  if (lower.includes("quota")) return "PROVIDER_QUOTA_EXHAUSTED";
+  if (lower.includes("unavailable")) return "PROVIDER_UNAVAILABLE";
+  if (lower.includes("timeout") || lower.includes("aborted")) {
+    return lower.includes("aborted") ? "ABORTED" : "TIMEOUT";
+  }
+  if (lower.includes("parse") || lower.includes("json")) return "PARSE_ERROR";
+  if (lower.includes("no result")) return "NO_RESULT";
+  if (lower.includes("network") || lower.includes("fetch")) return "NETWORK_ERROR";
+  return fallback;
+}
+var AIError = class _AIError extends Error {
+  type;
+  code;
+  cause;
+  metadata;
+  constructor(typeOrMessage, messageOrCode, cause, metadata = {}) {
+    let effectiveType;
+    let effectiveMessage;
+    let effectiveCode;
+    if (KNOWN_ERROR_TYPES.has(typeOrMessage)) {
+      effectiveType = typeOrMessage;
+      effectiveMessage = messageOrCode ?? "";
+      effectiveCode = effectiveType;
+    } else {
+      effectiveMessage = typeOrMessage;
+      effectiveCode = messageOrCode ?? "UNKNOWN";
+      effectiveType = mapCodeToType(effectiveCode);
+    }
+    super(effectiveMessage);
+    this.name = "AIError";
+    this.type = effectiveType;
+    this.code = effectiveCode;
+    this.cause = cause;
+    this.metadata = metadata;
+  }
+  static from(error, fallbackCode = "UNKNOWN") {
+    if (error instanceof _AIError) return error;
+    if (error instanceof Error) {
+      const code = mapMessageToCode(error.message, fallbackCode);
+      return new _AIError(error.message, code, error);
+    }
+    return new _AIError(String(error), fallbackCode, error);
+  }
+  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,
+      code: this.code,
+      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 MESSAGE_ID_PREFIX = "msg-";
+var CHAT_MESSAGE_ID_SUFFIX_LENGTH = 9;
+var USER_ROLE = "user";
+var ASSISTANT_ROLE = "assistant";
+var QUEUE_PRIORITY_USER_REQUEST = 10;
+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)?\s*\n?([\s\S]*?)\n?```/;
+var JSON_OBJECT_PATTERN = /\{[\s\S]*\}/;
+var JSON_ARRAY_PATTERN = /\[[\s\S]*\]/;
+
+// src/core/parsers/sse-lines.ts
+function isSseDataLine(line) {
+  return line.startsWith(SSE_PREFIX) || line.startsWith("data:");
+}
+function extractSseDataPayload(line) {
+  if (line.startsWith(SSE_PREFIX)) {
+    return line.slice(SSE_PREFIX.length);
+  }
+  if (line.startsWith("data:")) {
+    return line.slice(5);
+  }
+  return line;
+}
+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].trim();
+  return null;
+}
+function extractJsonObject(content) {
+  const match = content.match(JSON_OBJECT_PATTERN);
+  if (match && match[0]) return match[0];
+  return null;
+}
+function extractJsonArray(content) {
+  const match = content.match(JSON_ARRAY_PATTERN);
+  if (match && match[0]) return match[0];
+  return null;
+}
+function repairCommonJsonDefects(text) {
+  return text.replace(/(:\s*-?\d+(?:\.\d+)?)\s*"/g, "$1").replace(/(:\s*"[^"]*")"/g, "$1");
+}
+function extractJsonCandidate(content) {
+  const fromFence = extractJsonFromCodeFence(content);
+  if (fromFence) return fromFence;
+  const objectIndex = content.indexOf("{");
+  const arrayIndex = content.indexOf("[");
+  if (objectIndex !== -1 && (arrayIndex === -1 || objectIndex < arrayIndex)) {
+    const obj = extractJsonObject(content);
+    if (obj) return obj;
+  } else if (arrayIndex !== -1) {
+    const arr = extractJsonArray(content);
+    if (arr) return arr;
+  }
+  return content.trim();
+}
+
+// src/core/parsers/json-response.parser.ts
+var JsonResponseParser = class {
+  parse(rawContent) {
+    const candidate = extractJsonCandidate(rawContent);
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      try {
+        return JSON.parse(repairCommonJsonDefects(candidate));
+      } catch (error) {
+        throw new AIError(
+          "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+          "Failed to parse structured response as JSON",
+          error instanceof Error ? error : void 0,
+          { rawContent }
+        );
+      }
+    }
+  }
+};
+
+// 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"
+    }
+  });
+}
+
+// src/providers/base/provider.types.ts
+function isTextProvider(provider) {
+  return provider.capabilities.includes("text");
+}
+function isMediaProvider(provider) {
+  return provider.capabilities.includes("image") || provider.capabilities.includes("video");
+}
+
+// src/content/domain/limits/ProviderTimingConfig.ts
+var ProviderTimingConfig = {
+  DEFAULT_TIMEOUT_MS: 3e4,
+  DEFAULT_RETRY_ATTEMPTS: 3,
+  FAL_TIMEOUT_MS: 12e4,
+  FAL_RETRY_ATTEMPTS: 2,
+  GEMINI_TIMEOUT_MS: 6e4,
+  GEMINI_RETRY_ATTEMPTS: 3,
+  HEALTH_CHECK_TTL_MS: 5 * 60 * 1e3,
+  RETRY_BACKOFF_BASE_MS: 1e3
+};
+
+// src/content/domain/calculations/RetryBackoffDelay.ts
+function calculateRetryBackoffDelayMs(attemptIndex) {
+  return ProviderTimingConfig.RETRY_BACKOFF_BASE_MS * Math.pow(2, attemptIndex);
+}
+
+// src/providers/base/base.provider.ts
+var BaseProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async healthCheck() {
+    if (!this.config.apiKey) {
+      return "unavailable";
+    }
+    return "healthy";
+  }
+  async estimateCost(_request) {
+    return 0;
+  }
+  async fetchWithTimeout(url, options, timeout) {
+    const effectiveTimeout = timeout ?? this.config.timeout ?? ProviderTimingConfig.DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async withRetry(fn, maxAttempts) {
+    const attempts = maxAttempts ?? this.config.retryAttempts ?? ProviderTimingConfig.DEFAULT_RETRY_ATTEMPTS;
+    let lastError;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (i < attempts - 1) {
+          await new Promise((resolve) => setTimeout(resolve, calculateRetryBackoffDelayMs(i)));
+        }
+      }
+    }
+    throw lastError || new Error("Retry attempts exhausted");
+  }
+};
+var ProviderError = class extends AIError {
+  constructor(message, providerId, originalError) {
+    super(message, "PROVIDER_ERROR", originalError);
+    this.providerId = providerId;
+    this.name = "ProviderError";
+  }
+  providerId;
+};
+
+// src/providers/factory/provider.factory.ts
+var ProviderFactory = class {
+  providers = /* @__PURE__ */ new Map();
+  healthCache = /* @__PURE__ */ new Map();
+  priority;
+  fallbackEnabled;
+  defaultTier;
+  constructor(config = {}) {
+    this.priority = config.priority ?? [];
+    this.fallbackEnabled = config.fallbackEnabled ?? true;
+    this.defaultTier = config.defaultTier ?? "balanced";
+  }
+  register(provider) {
+    this.providers.set(provider.id, provider);
+  }
+  getProvider(id) {
+    return this.providers.get(id);
+  }
+  getAllProviders() {
+    return Array.from(this.providers.values());
+  }
+  getByCapability(capability) {
+    return this.getAllProviders().filter(
+      (provider) => provider.capabilities.includes(capability)
+    );
+  }
+  getTextProviders() {
+    return this.getAllProviders().filter(isTextProvider);
+  }
+  hasTextProvider() {
+    return this.getByCapability("text").length > 0;
+  }
+  /* ---------- neutral text surface ---------- */
+  /**
+   * Single-chat entry point: resolves a healthy text provider by priority,
+   * injects the default tier when the request names neither model nor tier,
+   * and walks the fallback chain on failure. Providers map tiers onto their
+   * own models, so switching Groq→Anthropic is a config change.
+   */
+  async chat(request) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    return this.executeWithFallback(
+      "text",
+      (provider) => provider.generate(effective)
+    );
+  }
+  async chatStream(request, callbacks) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    let lastError;
+    const attemptCallbacks = {
+      onChunk: callbacks.onChunk,
+      onComplete: callbacks.onComplete
+    };
+    const providers = this.getByCapability("text");
+    if (providers.length === 0) {
+      throw this.noProviderError("text");
+    }
+    const ordered = this.orderByPriority(providers);
+    for (const provider of ordered) {
+      if (!this.isProviderHealthy(provider.id)) continue;
+      try {
+        return await provider.stream(effective, attemptCallbacks);
+      } catch (error) {
+        lastError = error;
+        this.markDegraded(provider.id);
+        if (!this.fallbackEnabled) {
+          callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+          throw error;
+        }
+      }
+    }
+    const failure = new AIError(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      `All providers failed for capability 'text'`,
+      lastError instanceof Error ? lastError : void 0
+    );
+    callbacks.onError?.(lastError instanceof Error ? lastError : failure);
+    throw failure;
+  }
+  /** AsyncGenerator adapter over chatStream — A's familiar consumption shape. */
+  async *streamText(request) {
+    const queue = [];
+    let wake = null;
+    let finished = false;
+    let failure;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    request.signal?.addEventListener("abort", onAbort);
+    const effectiveRequest = { ...request, signal: controller.signal };
+    const notify = () => {
+      const resolve = wake;
+      wake = null;
+      resolve?.();
+    };
+    const completion = this.chatStream(effectiveRequest, {
+      onChunk: (chunk) => {
+        queue.push(chunk);
+        notify();
+      }
+    }).then(
+      () => {
+        finished = true;
+        notify();
+      },
+      (error) => {
+        failure = error;
+        finished = true;
+        notify();
+      }
+    );
+    try {
+      while (!finished || queue.length > 0) {
+        if (queue.length === 0 && !finished) {
+          await new Promise((resolve) => {
+            wake = resolve;
+          });
+        }
+        while (queue.length > 0) {
+          yield queue.shift();
+        }
+        if (failure) throw failure;
+      }
+      await completion;
+    } finally {
+      controller.abort();
+      request.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  async generateJson(request) {
+    const effective = request.model || request.tier ? request : { ...request, tier: this.defaultTier };
+    return this.executeWithFallback(
+      "text",
+      (provider) => provider.generateStructured(effective)
+    );
+  }
+  /* ---------- content-layer string facade (ITextGenerator) ---------- */
+  async generateText(prompt, options = {}) {
+    const result = await this.chat({
+      messages: [{ role: "user", content: prompt }],
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP
+    });
+    return result.text;
+  }
+  generateTextStream(prompt, options = {}) {
+    return this.streamText({
+      messages: [{ role: "user", content: prompt }],
+      model: options.model,
+      maxTokens: options.maxTokens,
+      temperature: options.temperature,
+      topP: options.topP
+    });
+  }
+  /* ---------- media surface ---------- */
+  async generateImage(request) {
+    return this.executeWithFallback(
+      "image",
+      (provider) => provider.generateImage(request)
+    );
+  }
+  async generateVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.generateVideo(request)
+    );
+  }
+  async imageToVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.imageToVideo(request)
+    );
+  }
+  async videoToVideo(request) {
+    return this.executeWithFallback(
+      "video",
+      (provider) => provider.videoToVideo(request)
+    );
+  }
+  /* ---------- health ---------- */
+  async checkProviderHealth(providerId, forceRefresh = false) {
+    const provider = this.providers.get(providerId);
+    if (!provider) {
+      return "unavailable";
+    }
+    const cached = this.healthCache.get(providerId);
+    const now = Date.now();
+    const ttl = ProviderTimingConfig.HEALTH_CHECK_TTL_MS;
+    if (!forceRefresh && cached && now - cached.timestamp < ttl) {
+      return cached.health;
+    }
+    try {
+      const health = await provider.healthCheck();
+      this.healthCache.set(providerId, { health, timestamp: now });
+      return health;
+    } catch {
+      this.healthCache.set(providerId, { health: "unavailable", timestamp: now });
+      return "unavailable";
+    }
+  }
+  isProviderHealthy(providerId) {
+    const cached = this.healthCache.get(providerId);
+    if (!cached) {
+      return true;
+    }
+    return cached.health === "healthy" || cached.health === "degraded";
+  }
+  async refreshAllHealth() {
+    await Promise.all(
+      Array.from(this.providers.keys()).map((id) => this.checkProviderHealth(id))
+    );
+  }
+  /* ---------- internals ---------- */
+  async executeWithFallback(capability, fn) {
+    const providers = this.getByCapability(capability);
+    if (providers.length === 0) {
+      throw this.noProviderError(capability);
+    }
+    let lastError;
+    for (const provider of this.orderByPriority(providers)) {
+      if (!this.isProviderHealthy(provider.id)) {
+        continue;
+      }
+      try {
+        return await fn(provider);
+      } catch (error) {
+        lastError = error;
+        this.markDegraded(provider.id);
+        if (!this.fallbackEnabled) {
+          throw error;
+        }
+      }
+    }
+    throw new AIError(
+      "SERVER_ERROR" /* SERVER_ERROR */,
+      `All providers failed for capability '${capability}'`,
+      lastError instanceof Error ? lastError : void 0
+    );
+  }
+  orderByPriority(providers) {
+    if (this.priority.length === 0) {
+      return providers;
+    }
+    const ordered = [];
+    for (const providerId of this.priority) {
+      const provider = providers.find((p) => p.id === providerId);
+      if (provider) ordered.push(provider);
+    }
+    for (const provider of providers) {
+      if (!this.priority.includes(provider.id)) {
+        ordered.push(provider);
+      }
+    }
+    return ordered;
+  }
+  markDegraded(providerId) {
+    const cached = this.healthCache.get(providerId);
+    if (cached) {
+      this.healthCache.set(providerId, { health: "degraded", timestamp: cached.timestamp });
+    }
+  }
+  noProviderError(capability) {
+    return new AIError(
+      "MISSING_CONFIG" /* MISSING_CONFIG */,
+      `No provider registered for capability '${capability}' \u2014 create one with createAI() and include its config block`
+    );
+  }
+};
+
+// src/providers/anthropic/anthropic.constants.ts
+var ANTHROPIC_MODELS = {
+  OPUS_5_5: "claude-opus-5-5",
+  SONNET_5_5: "claude-sonnet-5-5",
+  HAIKU_5_5: "claude-haiku-5-5"
+};
+var ANTHROPIC_TIERS = {
+  fast: ANTHROPIC_MODELS.HAIKU_5_5,
+  balanced: ANTHROPIC_MODELS.SONNET_5_5,
+  powerful: ANTHROPIC_MODELS.OPUS_5_5
+};
+var ANTHROPIC_API_VERSION = "2026-10-21";
+var ANTHROPIC_DEFAULT_MAX_TOKENS = 16e3;
+var ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+var ANTHROPIC_MESSAGES_PATH = "/v1/messages";
+var ANTHROPIC_MODELS_PATH = "/v1/models";
+var ANTHROPIC_TIMEOUTS = {
+  DEFAULT: 6e4,
+  STREAMING: 12e4
+};
+var ANTHROPIC_HEADERS = {
+  CONTENT_TYPE: "Content-Type",
+  APPLICATION_JSON: "application/json",
+  API_KEY: "x-api-key",
+  VERSION: "anthropic-version"
+};
+var ANTHROPIC_DEFAULT_EFFORT = {
+  [ANTHROPIC_MODELS.OPUS_5_5]: "medium",
+  [ANTHROPIC_MODELS.SONNET_5_5]: "high",
+  [ANTHROPIC_MODELS.HAIKU_5_5]: "medium"
+};
+
+// src/providers/anthropic/anthropic-http.transport.ts
+var AnthropicHttpTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async postMessages(request, options = {}) {
+    const url = `${this.baseUrl()}${ANTHROPIC_MESSAGES_PATH}`;
+    const timeout = this.config.timeoutMs ?? ANTHROPIC_TIMEOUTS.DEFAULT;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onExternalAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onExternalAbort);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ ...request, stream: false }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      return await response.json();
+    } catch (error) {
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      options.signal?.removeEventListener("abort", onExternalAbort);
+    }
+  }
+  async streamMessages(request, options = {}) {
+    const url = `${this.baseUrl()}${ANTHROPIC_MESSAGES_PATH}`;
+    const timeout = this.config.timeoutMs ?? ANTHROPIC_TIMEOUTS.STREAMING;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onExternalAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onExternalAbort);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ ...request, stream: true }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      if (!response.body) {
+        throw new AIError("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+      }
+      return response.body;
+    } catch (error) {
+      options.signal?.removeEventListener("abort", onExternalAbort);
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async listModels() {
+    const url = `${this.baseUrl()}${ANTHROPIC_MODELS_PATH}`;
+    return fetch(url, {
+      method: "GET",
+      headers: this.buildHeaders()
+    });
+  }
+  baseUrl() {
+    return this.config.baseUrl ?? ANTHROPIC_BASE_URL;
+  }
+  buildHeaders() {
+    return {
+      [ANTHROPIC_HEADERS.CONTENT_TYPE]: ANTHROPIC_HEADERS.APPLICATION_JSON,
+      [ANTHROPIC_HEADERS.API_KEY]: this.config.apiKey,
+      [ANTHROPIC_HEADERS.VERSION]: ANTHROPIC_API_VERSION
+    };
+  }
+  async throwFromErrorResponse(response) {
+    const errorMessage = await extractErrorMessageFromResponse(response);
+    const metadata = {
+      status: response.status,
+      url: response.url
+    };
+    throw new AIError(
+      classifyHttpStatus(response.status),
+      errorMessage,
+      void 0,
+      metadata
+    );
+  }
+  normalizeError(error) {
+    if (error instanceof AIError) return error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new AIError(
+          "ABORT_ERROR" /* ABORT_ERROR */,
+          "Request was aborted by the client",
+          error
+        );
+      }
+      if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
+        return new AIError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Network error: Unable to connect to the AI service",
+          error
+        );
+      }
+    }
+    return new AIError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      error instanceof Error ? error.message : "Unknown error occurred",
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+
+// src/providers/anthropic/anthropic-request.builder.ts
+var AnthropicRequestBuilder = class _AnthropicRequestBuilder {
+  model;
+  messages = [];
+  systemPrompt;
+  maxTokens = ANTHROPIC_DEFAULT_MAX_TOKENS;
+  effort;
+  stopSequences;
+  streamEnabled = false;
+  constructor(model) {
+    this.model = model;
+  }
+  static for(model) {
+    return new _AnthropicRequestBuilder(model);
+  }
+  withRequest(request) {
+    this.messages = toAnthropicMessages(request.messages);
+    this.systemPrompt = request.systemPrompt;
+    if (request.maxTokens !== void 0) this.maxTokens = request.maxTokens;
+    if (request.stopSequences !== void 0 && request.stopSequences.length > 0) {
+      this.stopSequences = [...request.stopSequences];
+    }
+    return this;
+  }
+  withEffort(effort) {
+    this.effort = effort;
+    return this;
+  }
+  withStream(stream) {
+    this.streamEnabled = stream;
+    return this;
+  }
+  withSystemPromptOverride(systemPrompt) {
+    this.systemPrompt = systemPrompt;
+    return this;
+  }
+  withMessagesOverride(messages) {
+    this.messages = messages;
+    return this;
+  }
+  build() {
+    const request = {
+      model: this.model,
+      messages: this.messages,
+      max_tokens: this.maxTokens,
+      output_config: {
+        effort: this.effort ?? defaultEffortForModel(this.model)
+      }
+    };
+    if (this.systemPrompt !== void 0 && this.systemPrompt.length > 0) {
+      request.system = this.systemPrompt;
+    }
+    if (this.stopSequences !== void 0) {
+      request.stop_sequences = this.stopSequences;
+    }
+    if (this.streamEnabled) {
+      request.stream = true;
+    }
+    return request;
+  }
+};
+function toAnthropicMessages(messages) {
+  return messages.filter((message) => message.role !== "system" && message.content.length > 0).map((message) => ({
+    role: message.role,
+    content: message.content
+  }));
+}
+function defaultEffortForModel(model) {
+  return ANTHROPIC_DEFAULT_EFFORT[model] ?? "medium";
+}
+
+// src/providers/anthropic/anthropic-stream.parser.ts
+function mapAnthropicStopReason(reason) {
+  if (reason === "end_turn") return "stop";
+  if (reason === "stop_sequence") return "stop";
+  if (reason === "max_tokens") return "length";
+  if (reason === "refusal") return "refusal";
+  return void 0;
+}
+async function consumeAnthropicStream(stream, callbacks) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let buffer = "";
+  let model = null;
+  let inputTokens;
+  let outputTokens;
+  let finishReason;
+  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);
+    let event;
+    try {
+      event = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    switch (event.type) {
+      case "message_start":
+        model = event.message.model;
+        if (event.message.usage?.input_tokens !== void 0) {
+          inputTokens = event.message.usage.input_tokens;
+        }
+        break;
+      case "content_block_delta":
+        if (typeof event.delta.text === "string" && event.delta.text.length > 0) {
+          chunks.push(event.delta.text);
+          callbacks.onChunk?.(event.delta.text);
+        }
+        break;
+      case "message_delta":
+        if (event.delta?.stop_reason !== void 0 && event.delta.stop_reason !== null) {
+          finishReason = mapAnthropicStopReason(event.delta.stop_reason);
+        }
+        if (event.usage?.output_tokens !== void 0) {
+          outputTokens = event.usage.output_tokens;
+        }
+        break;
+      case "message_stop":
+        break;
+      case "error": {
+        const errType = event.error.type;
+        const mappedType = errType === "rate_limit_error" ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : errType === "authentication_error" ? "INVALID_API_KEY" /* INVALID_API_KEY */ : errType === "invalid_request_error" ? "CLIENT_ERROR" /* CLIENT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */;
+        throw new AIError(
+          mappedType,
+          event.error.message || "Anthropic stream failed mid-flight"
+        );
+      }
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = 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) consumeLine(line);
+    }
+    buffer += 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 {
+    text: chunks.join(""),
+    model,
+    inputTokens,
+    outputTokens,
+    finishReason
+  };
+}
+
+// src/providers/anthropic/anthropic.provider.ts
+var REFUSAL_FALLBACK_TEXT = "I'm not able to help with that request. Could you rephrase or ask something else?";
+var AnthropicProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.transport = new AnthropicHttpTransport(config);
+    this.tiers = mergeTierOverrides(ANTHROPIC_TIERS, config.models);
+  }
+  config;
+  id = "anthropic";
+  name = "Anthropic";
+  capabilities = ["text"];
+  transport;
+  tiers;
+  jsonParser = new JsonResponseParser();
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    if (!this.config.apiKey) return "unavailable";
+    try {
+      const response = await this.transport.listModels();
+      if (response.ok) return "healthy";
+      if (response.status === 401 || response.status === 403) return "unavailable";
+      return "degraded";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async estimateCost() {
+    return 0;
+  }
+  async generate(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const wireRequest = new AnthropicRequestBuilder(model).withRequest(request).withEffort(this.config.effort).build();
+    const response = await this.transport.postMessages(wireRequest, {
+      signal: request.signal
+    });
+    return this.toGenerationResult(response, model);
+  }
+  async generateStructured(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const messages = [...request.messages];
+    const lastUserIndex = findLastIndex(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    const structuredPrompt = new StructuredPromptBuilder(
+      messages[lastUserIndex].content
+    ).withSchema(request.schema).build();
+    messages[lastUserIndex] = { role: "user", content: structuredPrompt };
+    const wireRequest = new AnthropicRequestBuilder(model).withRequest({ ...request, messages }).withEffort(this.config.effort).build();
+    const response = await this.transport.postMessages(wireRequest, {
+      signal: request.signal
+    });
+    const result = this.toGenerationResult(response, model);
+    return { value: this.jsonParser.parse(result.text), result };
+  }
+  async stream(request, callbacks) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const wireRequest = new AnthropicRequestBuilder(model).withRequest(request).withEffort(this.config.effort).withStream(true).build();
+    const streamBody = await this.transport.streamMessages(wireRequest, {
+      signal: request.signal
+    });
+    try {
+      const outcome = await consumeAnthropicStream(streamBody, callbacks);
+      const text = outcome.text.length > 0 ? outcome.text : refusalTextFor(outcome.finishReason);
+      const result = {
+        text,
+        usage: {
+          inputTokens: outcome.inputTokens ?? 0,
+          outputTokens: outcome.outputTokens ?? 0
+        },
+        model: outcome.model ?? model,
+        providerId: this.id,
+        finishReason: outcome.finishReason
+      };
+      callbacks.onComplete?.(result);
+      return result;
+    } catch (error) {
+      callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  toGenerationResult(response, fallbackModel) {
+    const text = extractText(response.content);
+    const finishReason = mapAnthropicStopReason(response.stop_reason);
+    if (text.length === 0) {
+      if (finishReason === "refusal") {
+        return {
+          text: REFUSAL_FALLBACK_TEXT,
+          usage: mapAnthropicUsage(response.usage),
+          model: response.model || fallbackModel,
+          providerId: this.id,
+          finishReason
+        };
+      }
+      throw new AIError(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "No content generated from Anthropic API",
+        void 0,
+        { model: response.model || fallbackModel, stopReason: response.stop_reason ?? void 0 }
+      );
+    }
+    return {
+      text,
+      usage: mapAnthropicUsage(response.usage),
+      model: response.model || fallbackModel,
+      providerId: this.id,
+      finishReason
+    };
+  }
+};
+function extractText(blocks) {
+  return blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function refusalTextFor(finishReason) {
+  return finishReason === "refusal" ? REFUSAL_FALLBACK_TEXT : "";
+}
+function mapAnthropicUsage(usage) {
+  if (!usage) return void 0;
+  return {
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens
+  };
+}
+function findLastIndex(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+
+// src/providers/groq/groq.constants.ts
+var GROQ_MODELS = {
+  LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant",
+  LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile",
+  LLAMA_3_1_70B_VERSATILE: "llama-3.1-70b-versatile",
+  GPT_OSS_20B: "openai/gpt-oss-20b",
+  GPT_OSS_120B: "openai/gpt-oss-120b",
+  MIXTRAL_8X7B: "mixtral-8x7b-32768",
+  GEMMA_2_9B: "gemma2-9b-it",
+  LLAMA_4_SCOUT_17B: "meta-llama/llama-4-scout-17b-16e-instruct",
+  KIMI_K2_INSTRUCT: "moonshotai/kimi-k2-instruct",
+  QWEN3_32B: "qwen/qwen3-32b"
+};
+var GROQ_TIERS = {
+  fast: GROQ_MODELS.LLAMA_3_1_8B_INSTANT,
+  balanced: GROQ_MODELS.LLAMA_3_3_70B_VERSATILE,
+  powerful: GROQ_MODELS.GPT_OSS_120B
+};
+var DEFAULT_GENERATION_CONFIG = {
+  temperature: 0.7,
+  maxTokens: 1024,
+  topP: 1
+};
+var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
+var CHAT_COMPLETIONS_PATH = "/chat/completions";
+var GROQ_TIMEOUTS = {
+  DEFAULT: 3e4,
+  STREAMING: 6e4
+};
+var HTTP_HEADERS = {
+  CONTENT_TYPE: "Content-Type",
+  APPLICATION_JSON: "application/json",
+  AUTHORIZATION: "Authorization",
+  BEARER_PREFIX: "Bearer "
+};
+
+// src/providers/groq/groq-request.builder.ts
+var GroqChatRequestBuilder = class _GroqChatRequestBuilder {
+  model;
+  messages = [];
+  generationConfig = {};
+  streamEnabled = false;
+  jsonResponse = false;
+  constructor(model) {
+    this.model = model;
+  }
+  static for(model) {
+    return new _GroqChatRequestBuilder(model);
+  }
+  withMessages(messages) {
+    this.messages = [...messages];
+    return this;
+  }
+  withConfig(config) {
+    this.generationConfig = config ? { ...config } : {};
+    return this;
+  }
+  withStream(stream) {
+    this.streamEnabled = stream;
+    return this;
+  }
+  withJsonResponse(enabled) {
+    this.jsonResponse = enabled;
+    return this;
+  }
+  build() {
+    const cfg = this.generationConfig;
+    const request = {
+      model: this.model,
+      messages: this.messages,
+      temperature: cfg.temperature ?? DEFAULT_GENERATION_CONFIG.temperature,
+      max_tokens: cfg.maxTokens ?? DEFAULT_GENERATION_CONFIG.maxTokens,
+      top_p: cfg.topP ?? DEFAULT_GENERATION_CONFIG.topP
+    };
+    if (cfg.n !== void 0) request.n = cfg.n;
+    if (cfg.stop !== void 0) request.stop = cfg.stop;
+    if (cfg.frequencyPenalty !== void 0) request.frequency_penalty = cfg.frequencyPenalty;
+    if (cfg.presencePenalty !== void 0) request.presence_penalty = cfg.presencePenalty;
+    if (cfg.reasoningEffort !== void 0) request.reasoning_effort = cfg.reasoningEffort;
+    if (this.jsonResponse) {
+      request.response_format = { type: "json_object" };
+    }
+    if (this.streamEnabled) request.stream = true;
+    return request;
+  }
+};
+
+// src/providers/groq/groq-http-transport.ts
+var GroqHttpTransport = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  pendingAbortControllers = /* @__PURE__ */ new Set();
+  cancelPendingRequests() {
+    for (const controller of this.pendingAbortControllers) {
+      controller.abort();
+    }
+    this.pendingAbortControllers.clear();
+  }
+  async postChatCompletion(request) {
+    return this.request(CHAT_COMPLETIONS_PATH, {
+      ...request,
+      stream: false
+    });
+  }
+  async streamChatCompletion(request, options = {}) {
+    const url = `${this.baseUrl()}${CHAT_COMPLETIONS_PATH}`;
+    const timeout = this.config.timeoutMs ?? GROQ_TIMEOUTS.STREAMING;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const onExternalAbort = () => controller.abort();
+    options.signal?.addEventListener("abort", onExternalAbort);
+    this.pendingAbortControllers.add(controller);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ ...request, stream: true }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      if (!response.body) {
+        throw new AIError("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+      }
+      return response.body;
+    } catch (error) {
+      options.signal?.removeEventListener("abort", onExternalAbort);
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      this.pendingAbortControllers.delete(controller);
+    }
+  }
+  baseUrl() {
+    return this.config.baseUrl ?? GROQ_BASE_URL;
+  }
+  async request(endpoint, body) {
+    const url = `${this.baseUrl()}${endpoint}`;
+    const timeout = this.config.timeoutMs ?? GROQ_TIMEOUTS.DEFAULT;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    this.pendingAbortControllers.add(controller);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      return await response.json();
+    } catch (error) {
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      this.pendingAbortControllers.delete(controller);
+    }
+  }
+  buildHeaders() {
+    return {
+      [HTTP_HEADERS.CONTENT_TYPE]: HTTP_HEADERS.APPLICATION_JSON,
+      [HTTP_HEADERS.AUTHORIZATION]: `${HTTP_HEADERS.BEARER_PREFIX}${this.config.apiKey}`
+    };
+  }
+  async throwFromErrorResponse(response) {
+    const errorMessage = await extractErrorMessageFromResponse(response);
+    const metadata = {
+      status: response.status,
+      url: response.url
+    };
+    throw new AIError(
+      classifyHttpStatus(response.status),
+      errorMessage,
+      void 0,
+      metadata
+    );
+  }
+  normalizeError(error) {
+    if (error instanceof AIError) return error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new AIError(
+          "ABORT_ERROR" /* ABORT_ERROR */,
+          "Request was aborted by the client",
+          error
+        );
+      }
+      if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
+        return new AIError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Network error: Unable to connect to the AI service",
+          error
+        );
+      }
+    }
+    return new AIError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      error instanceof Error ? error.message : "Unknown error occurred",
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+
+// src/providers/groq/groq-http-client.ts
+var GroqHttpClient = class {
+  transport;
+  executor;
+  constructor(config, deps = {}) {
+    this.transport = deps.transport ?? new GroqHttpTransport(config);
+    const retryManager2 = deps.retryManager ?? new RetryManager();
+    const queue = deps.queue ?? new RequestQueue();
+    const deduplicator = deps.deduplicator ?? new RequestDeduplicator();
+    this.executor = new CompositeExecutor([
+      new DedupeExecutor(deduplicator, {
+        generateKey: (request) => deduplicatorKey(request, config.apiKey)
+      }),
+      new RetryExecutor(retryManager2),
+      new QueueExecutor(queue, QUEUE_PRIORITY_USER_REQUEST)
+    ]);
+  }
+  cancelPendingRequests() {
+    this.transport.cancelPendingRequests();
+  }
+  postChatCompletion(request) {
+    return this.executor.execute(
+      (req) => this.transport.postChatCompletion(req),
+      request
+    );
+  }
+  streamChatCompletion(request, options) {
+    return this.transport.streamChatCompletion(request, options);
+  }
+};
+function deduplicatorKey(request, apiKey) {
+  const { model, messages, stream: _stream, ...rest } = request;
+  const stable = JSON.stringify({
+    apiKey,
+    model,
+    messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    ...rest
+  });
+  return stable;
+}
+
+// src/providers/groq/groq-sse.ts
+function extractContentFromSsePayload(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    const delta = parsed.choices?.[0]?.delta?.content;
+    return typeof delta === "string" && delta.length > 0 ? delta : null;
+  } catch {
+    return null;
+  }
+}
+function mapGroqFinishReason(reason) {
+  if (reason === "stop") return "stop";
+  if (reason === "length") return "length";
+  if (reason === "content_filter") return "content_filter";
+  return void 0;
+}
+function mapGroqUsage(usage) {
+  if (!usage) return void 0;
+  return {
+    inputTokens: usage.prompt_tokens,
+    outputTokens: usage.completion_tokens,
+    totalTokens: usage.total_tokens
+  };
+}
+async function consumeGroqStream(stream, callbacks) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let buffer = "";
+  let model = null;
+  let finishReason;
+  let usage;
+  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;
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      return;
+    }
+    const errorBody = chunk.error;
+    if (errorBody) {
+      throw new AIError(
+        errorBody.message?.toLowerCase().includes("rate limit") ? "RATE_LIMIT_ERROR" /* RATE_LIMIT_ERROR */ : "SERVER_ERROR" /* SERVER_ERROR */,
+        errorBody.message || "Groq stream failed mid-flight"
+      );
+    }
+    if (chunk.model) model = chunk.model;
+    const choice = chunk.choices?.[0];
+    const delta = choice?.delta?.content;
+    if (typeof delta === "string" && delta.length > 0) {
+      chunks.push(delta);
+      callbacks.onChunk?.(delta);
+    }
+    if (choice?.finish_reason) {
+      finishReason = mapGroqFinishReason(choice.finish_reason);
+    }
+    const tailUsage = chunk.x_groq?.usage;
+    if (tailUsage) {
+      usage = mapGroqUsage(tailUsage);
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = 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) consumeLine(line);
+    }
+    buffer += 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 { text: chunks.join(""), model, finishReason, usage };
+}
+
+// src/providers/groq/groq.provider.ts
+var CACHE_LAYOUT_VERSION = 2;
+var STRUCTURED_TEMPERATURE = 0.1;
+var GroqProvider = class {
+  constructor(config) {
+    this.config = config;
+    this.client = new GroqHttpClient(config);
+    this.tiers = mergeTierOverrides(GROQ_TIERS, config.models);
+  }
+  config;
+  id = "groq";
+  name = "Groq";
+  capabilities = ["text"];
+  client;
+  tiers;
+  cache = new CacheManager();
+  jsonParser = new JsonResponseParser();
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    return this.config.apiKey ? "healthy" : "unavailable";
+  }
+  async estimateCost() {
+    return 0;
+  }
+  async generate(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const cacheKey = this.cache.generateKey({
+      v: CACHE_LAYOUT_VERSION,
+      provider: this.id,
+      op: "generate",
+      model,
+      messages: request.messages,
+      systemPrompt: request.systemPrompt ?? null,
+      temperature: request.temperature ?? null,
+      maxTokens: request.maxTokens ?? null,
+      topP: request.topP ?? null
+    });
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    const response = await this.client.postChatCompletion(
+      this.buildWireRequest(model, request)
+    );
+    const choice = response.choices?.[0];
+    const text = choice?.message?.content ?? "";
+    if (text.length === 0) {
+      throw new AIError(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "No content generated from Groq API",
+        void 0,
+        { model }
+      );
+    }
+    const result = {
+      text,
+      usage: mapGroqUsage(response.usage),
+      model: response.model || model,
+      providerId: this.id,
+      finishReason: mapGroqFinishReason(choice?.finish_reason)
+    };
+    this.cache.set(cacheKey, result);
+    return result;
+  }
+  async generateStructured(request) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const messages = toGroqMessages(request.messages, request.systemPrompt);
+    const lastUserIndex = findLastIndex2(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    const structuredPrompt = new StructuredPromptBuilder(
+      messages[lastUserIndex].content
+    ).withSchema(request.schema).build();
+    messages[lastUserIndex] = { role: "user", content: structuredPrompt };
+    const wireRequest = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(this.generationConfig(request, STRUCTURED_TEMPERATURE)).withJsonResponse(true).build();
+    const response = await this.client.postChatCompletion(wireRequest);
+    const choice = response.choices?.[0];
+    const text = choice?.message?.content ?? "";
+    if (text.length === 0) {
+      throw new AIError(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "No content generated from Groq API",
+        void 0,
+        { model }
+      );
+    }
+    return {
+      value: this.jsonParser.parse(text),
+      result: {
+        text,
+        usage: mapGroqUsage(response.usage),
+        model: response.model || model,
+        providerId: this.id,
+        finishReason: mapGroqFinishReason(choice?.finish_reason)
+      }
+    };
+  }
+  async stream(request, callbacks) {
+    const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+    const streamBody = await this.client.streamChatCompletion(
+      this.buildWireRequest(model, request),
+      { signal: request.signal }
+    );
+    try {
+      const outcome = await consumeGroqStream(streamBody, callbacks);
+      if (outcome.text.length === 0) {
+        throw new AIError(
+          "SERVER_ERROR" /* SERVER_ERROR */,
+          "No content generated from Groq API",
+          void 0,
+          { model }
+        );
+      }
+      const result = {
+        text: outcome.text,
+        usage: outcome.usage,
+        model: outcome.model ?? model,
+        providerId: this.id,
+        finishReason: outcome.finishReason
+      };
+      callbacks.onComplete?.(result);
+      return result;
+    } catch (error) {
+      callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }
+  }
+  getCacheStats() {
+    return this.cache.getStats();
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  cancelPendingRequests() {
+    this.client.cancelPendingRequests();
+  }
+  buildWireRequest(model, request) {
+    return GroqChatRequestBuilder.for(model).withMessages(toGroqMessages(request.messages, request.systemPrompt)).withConfig(this.generationConfig(request)).build();
+  }
+  generationConfig(request, temperatureOverride) {
+    return {
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      ...temperatureOverride !== void 0 ? { temperature: temperatureOverride } : {},
+      ...request.maxTokens !== void 0 ? { maxTokens: request.maxTokens } : {},
+      ...request.topP !== void 0 ? { topP: request.topP } : {},
+      ...request.stopSequences !== void 0 && request.stopSequences.length > 0 ? { stop: [...request.stopSequences] } : {}
+    };
+  }
+};
+function toGroqMessages(messages, systemPrompt) {
+  const wire = [];
+  if (systemPrompt && systemPrompt.length > 0) {
+    wire.push({ role: "system", content: systemPrompt });
+  }
+  for (const message of messages) {
+    if (message.role === "system") {
+      wire.push({ role: "system", content: message.content });
+      continue;
+    }
+    wire.push({ role: message.role, content: message.content });
+  }
+  return wire;
+}
+function findLastIndex2(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+
+// src/content/domain/predicates/ProviderCostEstimator.ts
+var FAL_FIXED_COST = 1;
+var GEMINI_IMAGE_COST = 0.02;
+var GEMINI_TEXT_PER_1K_CHARS_COST = 1e-4;
+function estimateFalGenerationCost(_request) {
+  return FAL_FIXED_COST;
+}
+function estimateGeminiGenerationCost(request) {
+  if (request.type === "image") return GEMINI_IMAGE_COST;
+  return GEMINI_TEXT_PER_1K_CHARS_COST;
+}
+
+// src/content/domain/limits/ModelDefaults.ts
+var ModelDefaults = {
+  FAL_IMAGE: "fal-ai/flux/schnell",
+  FAL_VIDEO: "fal-ai/hunyuan-video/1",
+  FAL_IMAGE_TO_VIDEO: "fal-ai/fast-animatediff/image-to-video",
+  GEMINI_TEXT: "gemini-2.0-flash",
+  GEMINI_IMAGE: "imagen-4.0-generate-001"};
+
+// src/providers/gemini/gemini.provider.ts
+var GEMINI_TIERS = {
+  fast: "gemini-2.0-flash-lite",
+  balanced: ModelDefaults.GEMINI_TEXT,
+  powerful: "gemini-2.5-pro"
+};
+var GeminiProvider = class extends BaseProvider {
+  id = "gemini";
+  name = "Google Gemini";
+  capabilities = ["text", "image"];
+  models;
+  tiers;
+  jsonParser = new JsonResponseParser();
+  constructor(config) {
+    super({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://generativelanguage.googleapis.com/v1beta",
+      timeout: config.timeout || ProviderTimingConfig.GEMINI_TIMEOUT_MS,
+      retryAttempts: config.retryAttempts || ProviderTimingConfig.GEMINI_RETRY_ATTEMPTS
+    });
+    this.models = {
+      text: ModelDefaults.GEMINI_TEXT,
+      image: ModelDefaults.GEMINI_IMAGE
+    };
+    if (config.models) {
+      this.models = { ...this.models, ...config.models };
+    }
+    this.tiers = mergeTierOverrides(
+      GEMINI_TIERS,
+      config.models ? { balanced: config.models.text } : void 0
+    );
+  }
+  resolveModel(tier) {
+    return resolveModel(this.tiers, tier, this.id);
+  }
+  async healthCheck() {
+    try {
+      if (!this.config.apiKey) {
+        return "unavailable";
+      }
+      const response = await this.fetchWithTimeout(
+        `${this.config.baseUrl}/models`,
+        {
+          method: "GET",
+          headers: this.authHeaders()
+        }
+      );
+      if (response.ok) return "healthy";
+      if (response.status === 401 || response.status === 403) return "unavailable";
+      return "degraded";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async estimateCost(request) {
+    return estimateGeminiGenerationCost(request);
+  }
+  async generate(request) {
+    try {
+      const model = request.model ?? this.resolveModel(request.tier ?? "balanced");
+      const systemMessages = request.messages.filter((m) => m.role === "system");
+      const systemPrompt = request.systemPrompt && request.systemPrompt.length > 0 ? request.systemPrompt : systemMessages.length > 0 ? systemMessages.map((m) => m.content).join("\n") : void 0;
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/models/${model}:generateContent`,
+          {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+              systemInstruction: systemPrompt && systemPrompt.length > 0 ? { parts: [{ text: systemPrompt }] } : void 0,
+              contents: toGeminiContents(request.messages),
+              generationConfig: {
+                temperature: request.temperature ?? 0.7,
+                maxOutputTokens: request.maxTokens ?? 2048,
+                topP: request.topP ?? 0.9
+              }
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        const message = await extractErrorMessageFromResponse(response);
+        throw new AIError(
+          classifyHttpStatus(response.status),
+          `Gemini API error (${response.status}): ${message}`,
+          void 0,
+          { status: response.status, model }
+        );
+      }
+      const data = await response.json();
+      const text = data.candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("") ?? "";
+      if (text.length === 0) {
+        throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No content generated from Gemini API", void 0, { model });
+      }
+      return {
+        text,
+        usage: data.usageMetadata ? {
+          inputTokens: data.usageMetadata.promptTokenCount,
+          outputTokens: data.usageMetadata.candidatesTokenCount,
+          totalTokens: data.usageMetadata.totalTokenCount
+        } : void 0,
+        model,
+        providerId: this.id,
+        finishReason: mapGeminiFinishReason(data.candidates?.[0]?.finishReason)
+      };
+    } catch (error) {
+      if (error instanceof AIError) throw error;
+      throw new AIError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        `Gemini text generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  async generateStructured(request) {
+    const messages = [...request.messages];
+    const lastUserIndex = findLastIndex3(messages, (m) => m.role === "user");
+    if (lastUserIndex === -1) {
+      throw new AIError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "generateStructured requires at least one user message"
+      );
+    }
+    messages[lastUserIndex] = {
+      role: "user",
+      content: new StructuredPromptBuilder(messages[lastUserIndex].content).withSchema(request.schema).build()
+    };
+    const result = await this.generate({ ...request, messages, temperature: 0.1 });
+    return { value: this.jsonParser.parse(result.text), result };
+  }
+  async stream(request, callbacks) {
+    const result = await this.generate(request);
+    callbacks.onChunk?.(result.text);
+    callbacks.onComplete?.(result);
+    return result;
+  }
+  async generateImage(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/models/${this.models.image}:generateContent`,
+          {
+            method: "POST",
+            headers: this.authHeaders(),
+            body: JSON.stringify({
+              contents: [{
+                parts: [{
+                  text: this.buildImagePrompt(request)
+                }]
+              }]
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        const message = await extractErrorMessageFromResponse(response);
+        throw new AIError(
+          classifyHttpStatus(response.status),
+          `Gemini image generation error (${response.status}): ${message}`,
+          void 0,
+          { status: response.status }
+        );
+      }
+      const data = await response.json();
+      const imageData = data.candidates?.[0]?.content?.parts?.[0]?.inlineData;
+      if (!imageData) {
+        throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No image data in Gemini response");
+      }
+      const url = `data:${imageData.mimeType};base64,${imageData.data}`;
+      return {
+        id: Date.now().toString(),
+        type: "image",
+        url,
+        metadata: {
+          provider: "gemini",
+          model: this.models.image,
+          mimeType: imageData.mimeType
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`Gemini image generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async generateVideo(_request) {
+    throw new Error("Gemini provider does not support video generation");
+  }
+  async imageToVideo(_request) {
+    throw new Error("Gemini provider does not support image-to-video conversion");
+  }
+  async videoToVideo(_request) {
+    throw new Error("Gemini provider does not support video-to-video conversion");
+  }
+  authHeaders() {
+    return {
+      "Content-Type": "application/json",
+      "x-goog-api-key": this.config.apiKey
+    };
+  }
+  buildImagePrompt(request) {
+    let prompt = request.prompt;
+    if (request.style) {
+      const styles = {
+        realistic: "photorealistic, highly detailed, 8k resolution",
+        cartoon: "cartoon style, colorful, animated",
+        abstract: "abstract art, modern, artistic",
+        minimalist: "minimalist, clean, simple",
+        vintage: "vintage style, retro, classic"
+      };
+      prompt += `, ${styles[request.style]}`;
+    }
+    if (request.quality === "ultra") {
+      prompt += ", ultra high quality, masterpiece";
+    }
+    return prompt;
+  }
+};
+function toGeminiContents(messages) {
+  return messages.filter((message) => message.role !== "system" && message.content.length > 0).map((message) => ({
+    role: message.role === "assistant" ? "model" : "user",
+    parts: [{ text: message.content }]
+  }));
+}
+function mapGeminiFinishReason(reason) {
+  if (reason === "STOP") return "stop";
+  if (reason === "MAX_TOKENS") return "length";
+  if (reason === "SAFETY" || reason === "PROHIBITED_CONTENT") return "content_filter";
+  return void 0;
+}
+function findLastIndex3(items, predicate) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    if (predicate(items[i])) return i;
+  }
+  return -1;
+}
+function createGeminiProvider(config) {
+  return new GeminiProvider(config);
+}
+
+// src/content/domain/predicates/FalImageRenderingOptions.ts
+var FAL_FORMAT_TO_IMAGE_SIZE = {
+  square: "square_hd",
+  landscape: "landscape_16_9",
+  portrait: "portrait_9_16",
+  story: "portrait_9_16",
+  banner: "landscape_16_9"
+};
+var FAL_DEFAULT_IMAGE_SIZE = "square_hd";
+var FAL_QUALITY_TO_STEPS = {
+  standard: 4,
+  high: 6,
+  ultra: 8
+};
+var FAL_DEFAULT_QUALITY_STEPS = 6;
+function resolveFalImageSize(format) {
+  if (!format) return FAL_DEFAULT_IMAGE_SIZE;
+  return FAL_FORMAT_TO_IMAGE_SIZE[format] ?? FAL_DEFAULT_IMAGE_SIZE;
+}
+function resolveFalInferenceSteps(quality) {
+  if (!quality) return FAL_DEFAULT_QUALITY_STEPS;
+  return FAL_QUALITY_TO_STEPS[quality] ?? FAL_DEFAULT_QUALITY_STEPS;
+}
+
+// src/providers/fal/fal.provider.ts
+var FalProvider = class extends BaseProvider {
+  id = "fal";
+  name = "FAL";
+  capabilities = ["image", "video"];
+  models;
+  constructor(config) {
+    super({
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl || "https://queue.fal.run",
+      timeout: config.timeout || ProviderTimingConfig.FAL_TIMEOUT_MS,
+      retryAttempts: config.retryAttempts || ProviderTimingConfig.FAL_RETRY_ATTEMPTS
+    });
+    this.models = {
+      image: ModelDefaults.FAL_IMAGE,
+      video: ModelDefaults.FAL_VIDEO,
+      imageToVideo: ModelDefaults.FAL_IMAGE_TO_VIDEO
+    };
+    if (config.models) {
+      this.models = { ...this.models, ...config.models };
+    }
+  }
+  async healthCheck() {
+    try {
+      if (!this.config.apiKey) {
+        return "unavailable";
+      }
+      const response = await this.fetchWithTimeout(
+        `${this.config.baseUrl}/fal-ai/flux/schnell/status`,
+        {
+          method: "HEAD",
+          headers: {
+            "Authorization": `Key ${this.config.apiKey}`
+          }
+        }
+      );
+      return response.ok ? "healthy" : "degraded";
+    } catch {
+      return "unavailable";
+    }
+  }
+  async estimateCost(request) {
+    return estimateFalGenerationCost();
+  }
+  async generateImage(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/${this.models.image}`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Key ${this.config.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              prompt: request.prompt,
+              image_size: resolveFalImageSize(request.format),
+              num_inference_steps: resolveFalInferenceSteps(request.quality),
+              num_images: request.quantity || 1
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`FAL API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return {
+        id: Date.now().toString(),
+        type: "image",
+        url: data.images?.[0]?.url,
+        metadata: {
+          provider: "fal",
+          model: this.models.image
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`FAL image generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async generateVideo(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/${this.models.video}`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Key ${this.config.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              prompt: request.prompt,
+              aspect_ratio: request.aspectRatio || "16:9"
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`FAL API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return {
+        id: Date.now().toString(),
+        type: "video",
+        url: data.video?.url,
+        metadata: {
+          provider: "fal",
+          model: this.models.video
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`FAL video generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async imageToVideo(request) {
+    try {
+      const response = await this.withRetry(async () => {
+        return await this.fetchWithTimeout(
+          `${this.config.baseUrl}/${this.models.imageToVideo}`,
+          {
+            method: "POST",
+            headers: {
+              "Authorization": `Key ${this.config.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              image_url: request.imageUrl,
+              motion: request.motion || "medium",
+              prompt: request.prompt
+            })
+          }
+        );
+      });
+      if (!response.ok) {
+        throw new Error(`FAL API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.error) {
+        throw new Error(data.error);
+      }
+      return {
+        id: Date.now().toString(),
+        type: "video",
+        url: data.video?.url,
+        metadata: {
+          provider: "fal",
+          model: this.models.imageToVideo
+        },
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (error) {
+      throw new Error(`FAL image-to-video failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  async videoToVideo(_request) {
+    throw new Error("FAL provider does not support video-to-video conversion");
+  }
+};
+function createFalProvider(config) {
+  return new FalProvider(config);
+}
+
+// src/providers/pruna/pruna-generate.ts
+var prunaCorePromise = null;
+async function loadPrunaCore() {
+  if (!prunaCorePromise) {
+    const specifier = "@umituz/pruna-provider/core";
+    prunaCorePromise = import(specifier);
+  }
+  return prunaCorePromise;
+}
+async function* generateWithPruna(request, apiKey, signal, onProgress) {
+  const prunaCore = await loadPrunaCore();
+  if (prunaCore.generateWithPruna) {
+    yield* prunaCore.generateWithPruna(request, apiKey, signal, onProgress);
+    return;
+  }
+  if (!prunaCore.submitPrediction || !prunaCore.pollForResult) {
+    throw new Error("@umituz/pruna-provider/core does not export required functions");
+  }
+  const modelId = request.model || (request.image ? "p-image-edit" : "p-image");
+  const prediction = await prunaCore.submitPrediction(modelId, request, apiKey, signal, onProgress);
+  if (prediction.output && typeof prediction.output === "object" && "url" in prediction.output) {
+    yield {
+      stage: "predicting",
+      result: { url: prediction.output.url, model: modelId }
+    };
+    return;
+  }
+  const pollUrl = prediction.status_url || prediction.generation_url;
+  if (!pollUrl) {
+    throw new Error("Pruna prediction response missing polling URL");
+  }
+  const resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
+  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+}
+
+// src/providers/pruna/pruna.provider.ts
+var PrunaProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  id = "pruna";
+  name = "Pruna AI";
+  capabilities = ["image", "video"];
+  async healthCheck() {
+    return this.config.apiKey ? "healthy" : "unavailable";
+  }
+  async estimateCost(_request) {
+    return 1;
+  }
+  async generateImage(request) {
+    let finalUrl;
+    const model = this.config.models?.textToImage;
+    for await (const stage of generateWithPruna(
+      { prompt: request.prompt, model, quality: request.quality },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No image generated by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "image",
+      url: finalUrl,
+      metadata: { provider: this.id, model: model ?? "p-image" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async generateVideo(request) {
+    let finalUrl;
+    const model = this.config.models?.textToVideo;
+    for await (const stage of generateWithPruna(
+      { prompt: request.prompt, model, duration: request.duration, aspectRatio: request.aspectRatio },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "video",
+      url: finalUrl,
+      metadata: { provider: this.id, model: model ?? "p-video" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async imageToVideo(request) {
+    let finalUrl;
+    for await (const stage of generateWithPruna(
+      { image: request.imageUrl, prompt: request.prompt, duration: request.duration, motion: request.motion },
+      this.config.apiKey
+    )) {
+      if (stage.error) throw stage.error;
+      if (stage.result?.url) finalUrl = stage.result.url;
+    }
+    if (!finalUrl) {
+      throw new AIError("SERVER_ERROR" /* SERVER_ERROR */, "No video generated from image by Pruna AI");
+    }
+    return {
+      id: Date.now().toString(),
+      type: "video",
+      url: finalUrl,
+      metadata: { provider: this.id, model: "p-image-to-video" },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async videoToVideo(_request) {
+    throw new AIError("CLIENT_ERROR" /* CLIENT_ERROR */, "Pruna AI provider does not support video-to-video conversion");
+  }
+};
+function createPrunaProvider(config) {
+  return new PrunaProvider(config);
+}
+
+// src/providers/factory/create-ai.ts
+function createAI(config = {}) {
+  const factory = new ProviderFactory({
+    priority: config.priority,
+    fallbackEnabled: config.fallbackEnabled,
+    defaultTier: config.defaultTier
+  });
+  if (config.anthropic?.apiKey) {
+    factory.register(new AnthropicProvider(config.anthropic));
+  }
+  if (config.groq?.apiKey) {
+    factory.register(new GroqProvider(config.groq));
+  }
+  if (config.gemini?.apiKey) {
+    factory.register(new GeminiProvider({ ...config.gemini, enabled: true }));
+  }
+  if (config.fal?.apiKey) {
+    factory.register(new FalProvider({ ...config.fal, enabled: true }));
+  }
+  if (config.pruna?.apiKey) {
+    factory.register(new PrunaProvider({ ...config.pruna, enabled: true }));
+  }
+  return factory;
+}
+
+// src/core/calculations/random-base36-suffix.ts
+var BASE_36_RADIX = 36;
+var DECIMAL_OFFSET = 2;
+function generateRandomBase36Suffix(length, random = Math.random) {
+  if (length <= 0) return "";
+  const raw = random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  if (raw.length >= length) return raw.slice(0, length);
+  let result = raw;
+  while (result.length < length) {
+    result += random().toString(BASE_36_RADIX).slice(DECIMAL_OFFSET);
+  }
+  return result.slice(0, length);
+}
+
+// src/chat/utils/chat-id-generator.ts
+var ID_PART_DELIMITER = "-";
+var ChatIdGenerator = class {
+  counter = 0;
+  randomLength;
+  constructor(randomLength = CHAT_MESSAGE_ID_SUFFIX_LENGTH) {
+    this.randomLength = randomLength;
+  }
+  next(sender) {
+    this.counter += 1;
+    const random = generateRandomBase36Suffix(this.randomLength);
+    return [
+      MESSAGE_ID_PREFIX,
+      Date.now(),
+      sender,
+      this.counter,
+      random
+    ].join(ID_PART_DELIMITER);
+  }
+};
+var chatIdGenerator = new ChatIdGenerator();
+
+// src/chat/utils/message-formatter.ts
+var MessageFormatter = class {
+  constructor(idGenerator = chatIdGenerator) {
+    this.idGenerator = idGenerator;
+  }
+  idGenerator;
+  /** Maps chat-domain history to neutral core messages; system senders are
+   *  dropped — the system prompt travels on the request's own slot. */
+  toCoreMessages(messages) {
+    const coreMessages = [];
+    for (const message of messages) {
+      if (message.sender === "system") continue;
+      coreMessages.push({
+        role: message.sender === "user" ? USER_ROLE : ASSISTANT_ROLE,
+        content: message.content
+      });
+    }
+    return coreMessages;
+  }
+  toChatMessage(content, sender) {
+    return {
+      id: this.idGenerator.next(sender),
+      sender,
+      content: content.trim(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: "text"
+    };
+  }
+};
+var messageFormatter = new MessageFormatter();
+
+// src/chat/utils/prompt-strategy.ts
+var DEFAULT_PROMPT_STRATEGY = {
+  resolve: (config) => {
+    if (config.systemPrompt && config.systemPrompt.length > 0) {
+      return config.systemPrompt;
+    }
+    return void 0;
+  }
+};
+
+// src/chat/services/chat.service.ts
+var DEFAULT_CONFIG = {
+  temperature: 0.8,
+  maxTokens: 500
+};
+var ChatService = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  engine;
+  config = DEFAULT_CONFIG;
+  promptStrategy = DEFAULT_PROMPT_STRATEGY;
+  storage = null;
+  initialize(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  updateConfig(config) {
+    this.config = { ...this.config, ...config };
+  }
+  setPromptStrategy(strategy) {
+    this.promptStrategy = strategy;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  async getConversation(conversationId) {
+    const storage = this.requireStorage();
+    const messages = await storage.getMessages(conversationId);
+    if (messages.length === 0) return null;
+    const last = messages[messages.length - 1];
+    const first = messages[0];
+    const companionId = String(first.metadata?.["companionId"] ?? "unknown");
+    const companionName = String(first.metadata?.["companionName"] ?? "Unknown");
+    return {
+      id: conversationId,
+      companionId,
+      companionName,
+      lastMessage: last,
+      messageCount: messages.length,
+      updatedAt: last.timestamp
+    };
+  }
+  async getConversations() {
+    if (this.storage && "getConversations" in this.storage && typeof this.storage.getConversations === "function") {
+      return this.storage.getConversations();
+    }
+    return [];
+  }
+  async sendMessage(input, signal) {
+    const userMessage = {
+      ...messageFormatter.toChatMessage(input.text, "user"),
+      type: input.type ?? "text",
+      ...input.imageUrl !== void 0 ? { imageUrl: input.imageUrl } : {}
+    };
+    const aiResponse = await this.generateAIResponse(
+      input.companionId,
+      input.text,
+      [],
+      signal
+    );
+    return { userMessage, aiResponse };
+  }
+  async generateAIResponse(companionId, userMessage, context = [], signal) {
+    const result = await this.run({
+      ...this.buildRequest(userMessage, context, signal)
+    });
+    return {
+      ...messageFormatter.toChatMessage(result.text, "assistant"),
+      metadata: {
+        companionId,
+        model: result.model,
+        usage: {
+          input_tokens: result.usage?.inputTokens,
+          output_tokens: result.usage?.outputTokens,
+          total_tokens: result.usage?.totalTokens
+        },
+        finishReason: result.finishReason
+      }
+    };
+  }
+  async generateStreamingResponse(userMessage, context, onChunk, signal) {
+    const request = this.buildRequest(userMessage, context, signal);
+    const result = await this.runStream(request, { onChunk });
+    return result.text;
+  }
+  buildRequest(userMessage, context, signal) {
+    const messages = messageFormatter.toCoreMessages(context);
+    messages.push({ role: "user", content: userMessage });
+    return {
+      messages,
+      systemPrompt: this.resolveSystemPrompt(),
+      model: this.config.model,
+      tier: this.config.tier,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      ...signal !== void 0 ? { signal } : {}
+    };
+  }
+  resolveSystemPrompt() {
+    const prompt = this.promptStrategy.resolve(this.config);
+    return prompt && prompt.length > 0 ? prompt : void 0;
+  }
+  async run(request) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chat(request);
+    }
+    return this.engine.generate(request);
+  }
+  async runStream(request, callbacks) {
+    if (this.engine instanceof ProviderFactory) {
+      return this.engine.chatStream(request, callbacks);
+    }
+    return this.engine.stream(request, callbacks);
+  }
+  requireStorage() {
+    if (!this.storage) {
+      throw new AIError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "ChatService.getConversation requires setStorage() to be called first."
+      );
+    }
+    return this.storage;
+  }
+};
+function extractTokenUsage(message) {
+  const meta = message.metadata;
+  if (!meta) return null;
+  const usage = meta["usage"];
+  if (!usage || typeof usage !== "object") return null;
+  const u = usage;
+  const inputTokens = readNumber(u, ["input_tokens", "prompt_tokens"]);
+  const outputTokens = readNumber(u, ["output_tokens", "completion_tokens"]);
+  const totalTokens = readNumber(u, ["total_tokens"]);
+  if (inputTokens === null || outputTokens === null || totalTokens === null) {
+    return null;
+  }
+  return {
+    promptTokens: inputTokens,
+    completionTokens: outputTokens,
+    totalTokens
+  };
+}
+function readNumber(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number") return value;
+  }
+  return null;
+}
+
+export { AIError, AIErrorType, ANTHROPIC_API_VERSION, ANTHROPIC_DEFAULT_MAX_TOKENS, ANTHROPIC_MODELS, ANTHROPIC_TIERS, AnthropicHttpTransport, AnthropicProvider, AnthropicRequestBuilder, BaseProvider, CacheManager, ChatIdGenerator, ChatService, CompositeExecutor, DEFAULT_API_KEY_RULE, DEFAULT_ERROR_CLASSIFICATION_RULE, DEFAULT_HTTP_STATUS_RULE, DEFAULT_PROMPT_STRATEGY, DEFAULT_RETRY_BACKOFF_MULTIPLIER, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_JITTER_FACTOR, DEFAULT_RETRY_MAX_ATTEMPTS, DEFAULT_RETRY_MAX_DELAY_MS, DebounceManager, DedupeExecutor, FalProvider, GEMINI_TIERS, GROQ_MODELS, GROQ_TIERS, GeminiProvider, GroqChatRequestBuilder, GroqHttpClient, GroqHttpTransport, GroqProvider, JSON_CODE_BLOCK_PATTERN, JSON_OBJECT_PATTERN, JsonResponseParser, ProviderError, ProviderFactory, PrunaProvider, 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, chatIdGenerator, clampScore, classifyHttpStatus, consumeAnthropicStream, consumeGroqStream, createAI, createFalProvider, createGeminiProvider, createPrunaProvider, createSseResponse, debounce, debounceManager, defaultEffortForModel, describeAIErrorType, extractContentFromSsePayload, extractErrorMessageFromJsonBody, extractErrorMessageFromResponse, extractJsonArray, extractJsonCandidate, extractJsonFromCodeFence, extractJsonObject, extractSseDataPayload, extractTokenUsage, formatErrorForLogging, generateWithPruna, isAuthErrorType, isMediaProvider, isRetryableErrorType, isSseDataLine, isSseDoneMarker, isTextProvider, isTextTier, isValidApiKey, mapAnthropicStopReason, mergeTierOverrides, messageFormatter, normalizeSseChunk, oneOfCatalog, repairCommonJsonDefects, requestDeduplicator, requestQueue, resolveModel, resolveUserFriendlyErrorMessage, resolveUserFriendlyMessage, retryManager, splitSseLines, throttle, throttleManager, toGroqMessages, validateApiKey, withRetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map