@umituz/web-ai-groq-provider 1.1.13 → 2.0.0

package/dist/domains/groq/index.cjs

@@ -0,0 +1,1499 @@
+'use strict';
+
+var react = require('react');
+
+// src/domains/groq/utils/groq-error.ts
+var GroqError = class extends Error {
+  type;
+  cause;
+  metadata;
+  constructor(type, message, cause, metadata = {}) {
+    super(message);
+    this.name = "GroqError";
+    this.type = type;
+    this.cause = cause;
+    this.metadata = metadata;
+  }
+  toString() {
+    const statusPart = typeof this.metadata.status === "number" ? ` (HTTP ${this.metadata.status})` : "";
+    return `${this.name} [${this.type}]: ${this.message}${statusPart}`;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      message: this.message,
+      metadata: this.metadata
+    };
+  }
+};
+
+// src/domains/groq/constants/error-types.ts
+var GroqErrorType = /* @__PURE__ */ ((GroqErrorType2) => {
+  GroqErrorType2["INVALID_API_KEY"] = "INVALID_API_KEY";
+  GroqErrorType2["MISSING_CONFIG"] = "MISSING_CONFIG";
+  GroqErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  GroqErrorType2["ABORT_ERROR"] = "ABORT_ERROR";
+  GroqErrorType2["RATE_LIMIT_ERROR"] = "RATE_LIMIT_ERROR";
+  GroqErrorType2["SERVER_ERROR"] = "SERVER_ERROR";
+  GroqErrorType2["CLIENT_ERROR"] = "CLIENT_ERROR";
+  GroqErrorType2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return GroqErrorType2;
+})(GroqErrorType || {});
+var USER_FRIENDLY_ERROR_MESSAGES = {
+  ["INVALID_API_KEY" /* INVALID_API_KEY */]: "Please check your Groq API key and try again.",
+  ["MISSING_CONFIG" /* MISSING_CONFIG */]: "The provider is not configured. Please call configureProvider 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 */]: "Groq 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/domains/groq/constants/groq.constants.ts
+var GROQ_MODELS = {
+  /** Llama 3.1 8B - Fast and efficient (560 T/s) */
+  LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant",
+  /** Llama 3.3 70B - Versatile and powerful (280 T/s) */
+  LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile",
+  /** Llama 3.1 70B - Versatile (280 T/s) */
+  LLAMA_3_1_70B_VERSATILE: "llama-3.1-70b-versatile",
+  /** GPT-OSS 20B - Experimental (1000 T/s) */
+  GPT_OSS_20B: "openai/gpt-oss-20b",
+  /** GPT-OSS 120B - Large experimental model */
+  GPT_OSS_120B: "openai/gpt-oss-120b",
+  /** Mixtral 8x7b - MoE model */
+  MIXTRAL_8X7B: "mixtral-8x7b-32768",
+  /** Gemma 2 9B - Google's model */
+  GEMMA_2_9B: "gemma2-9b-it",
+  /** Llama 4 Scout 17B - New model (30K T/s) */
+  LLAMA_4_SCOUT_17B: "meta-llama/llama-4-scout-17b-16e-instruct",
+  /** Kimi K2 - Moonshot AI model */
+  KIMI_K2_INSTRUCT: "moonshotai/kimi-k2-instruct",
+  /** Qwen 3 32B - Alibaba's model */
+  QWEN3_32B: "qwen/qwen3-32b"
+};
+var DEFAULT_MODELS = {
+  TEXT: GROQ_MODELS.LLAMA_3_1_8B_INSTANT,
+  FAST: GROQ_MODELS.LLAMA_3_1_8B_INSTANT,
+  EXPERIMENTAL: GROQ_MODELS.GPT_OSS_20B
+};
+var DEFAULT_GENERATION_CONFIG = {
+  temperature: 0.7,
+  maxTokens: 1024,
+  topP: 1
+};
+var API_ENDPOINTS = {
+  CHAT: "/chat/completions"
+};
+var DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
+var TIMEOUTS = {
+  DEFAULT: 3e4,
+  // 30 seconds
+  STREAMING: 6e4
+  // 60 seconds
+};
+
+// src/domains/groq/constants/identifier.constants.ts
+var CACHE_KEY_TYPE_COMPLETION = "completion";
+var CACHE_KEY_TYPE_CHAT = "chat";
+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/domains/groq/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/domains/groq/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/domains/groq/builders/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/domains/groq/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();
+  }
+  /** Build a stable cache key from a parameter object. */
+  generateKey(params) {
+    return buildCacheKey(params);
+  }
+  /**
+   * Dynamic cache statistics. All numbers are computed at call time
+   * from the current state; nothing is hardcoded.
+   */
+  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/domains/groq/builders/groq-request.builder.ts
+var GroqChatRequestBuilder = class _GroqChatRequestBuilder {
+  model;
+  messages = [];
+  generationConfig = {};
+  streamEnabled = 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;
+  }
+  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 (this.streamEnabled) request.stream = true;
+    return request;
+  }
+};
+
+// src/domains/groq/builders/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/domains/groq/constants/protocol.constants.ts
+var HTTP_HEADERS = {
+  CONTENT_TYPE: "Content-Type",
+  AUTHORIZATION: "Authorization",
+  APPLICATION_JSON: "application/json",
+  BEARER_PREFIX: "Bearer "
+};
+var SSE_PREFIX = "data: ";
+var SSE_DONE_MARKER = "[DONE]";
+var JSON_CODE_BLOCK_PATTERN = /```json\n([\s\S]*?)\n```/;
+var JSON_OBJECT_PATTERN = /\{[\s\S]*\}/;
+var CHAT_COMPLETIONS_PATH = "/chat/completions";
+
+// src/domains/groq/parsers/sse-line-extractor.ts
+function isSseDataLine(line) {
+  return line.startsWith(SSE_PREFIX);
+}
+function extractSseDataPayload(line) {
+  return line.slice(SSE_PREFIX.length);
+}
+function isSseDoneMarker(payload) {
+  return payload === SSE_DONE_MARKER;
+}
+function splitSseLines(rawChunk) {
+  return rawChunk.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+}
+function extractContentFromSsePayload(payload) {
+  try {
+    const parsed = JSON.parse(payload);
+    return parsed.choices?.[0]?.delta?.content ?? null;
+  } catch {
+    return null;
+  }
+}
+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/domains/groq/parsers/streaming-response.parser.ts
+var StreamingResponseParser = class {
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+  }
+  decoder = new TextDecoder();
+  async parse(stream) {
+    const reader = stream.getReader();
+    const contentChunks = [];
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = this.decoder.decode(value, { stream: true });
+        const normalized = normalizeSseChunk(chunk);
+        for (const item of normalized) {
+          if (item.isDone) continue;
+          const content = extractContentFromSsePayload(item.payload);
+          if (content !== null) {
+            contentChunks.push(content);
+            this.callbacks.onChunk(content);
+          }
+        }
+      }
+    } catch (error) {
+      if (error instanceof GroqError) throw error;
+      throw new GroqError(
+        "NETWORK_ERROR" /* NETWORK_ERROR */,
+        "Stream was interrupted",
+        error instanceof Error ? error : void 0
+      );
+    } finally {
+      reader.releaseLock();
+    }
+    return contentChunks.join("");
+  }
+};
+
+// src/domains/groq/parsers/json-content-extractor.ts
+function extractJsonFromCodeFence(content) {
+  const match = content.match(JSON_CODE_BLOCK_PATTERN);
+  if (match && match[1]) return match[1];
+  return null;
+}
+function extractJsonObject(content) {
+  const match = content.match(JSON_OBJECT_PATTERN);
+  if (match && match[0]) return match[0];
+  return null;
+}
+function extractJsonCandidate(content) {
+  return extractJsonFromCodeFence(content) ?? extractJsonObject(content) ?? content;
+}
+
+// src/domains/groq/parsers/json-response.parser.ts
+var JsonResponseParser = class {
+  parse(rawContent) {
+    const candidate = extractJsonCandidate(rawContent);
+    try {
+      return JSON.parse(candidate);
+    } catch (error) {
+      throw new GroqError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "Failed to parse structured response as JSON",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+
+// src/domains/groq/utils/message.util.ts
+var createUserMessage = (content) => ({
+  role: "user",
+  content
+});
+var createAssistantMessage = (content) => ({
+  role: "assistant",
+  content
+});
+var createSystemMessage = (content) => ({
+  role: "system",
+  content
+});
+var createMessage = (role, content) => ({
+  role,
+  content
+});
+var promptToMessages = (prompt) => [
+  createUserMessage(prompt)
+];
+var extractTextFromMessages = (messages) => messages.map((m) => m.content).join("\n\n");
+var formatMessagesForDisplay = (messages) => messages.map((m) => `[${m.role.toUpperCase()}]: ${m.content}`).join("\n\n---\n\n");
+
+// src/domains/groq/services/text-generation.service.ts
+var STRUCTURED_OUTPUT_TEMPERATURE = 0.1;
+var TextGenerationService = class {
+  constructor(httpClient, cache = new CacheManager()) {
+    this.httpClient = httpClient;
+    this.cache = cache;
+  }
+  jsonParser = new JsonResponseParser();
+  generateCompletion(prompt, options = {}) {
+    const model = options.model ?? DEFAULT_MODELS.TEXT;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_COMPLETION,
+        model,
+        prompt,
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(prompt)]).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateChatCompletion(messages, options = {}) {
+    const model = options.model ?? DEFAULT_MODELS.TEXT;
+    return this.executeWithCache(
+      {
+        type: CACHE_KEY_TYPE_CHAT,
+        model,
+        messages: [...messages],
+        config: options.generationConfig
+      },
+      async () => {
+        const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).build();
+        const response = await this.httpClient.postChatCompletion(request);
+        return this.extractContent(response.choices[0]?.message?.content);
+      }
+    );
+  }
+  generateStructured(prompt, options = {}) {
+    const model = options.model ?? DEFAULT_MODELS.TEXT;
+    const jsonPrompt = StructuredPromptBuilder.for(prompt).withSchema(options.schema).build();
+    const request = GroqChatRequestBuilder.for(model).withMessages([createUserMessage(jsonPrompt)]).withConfig({
+      ...options.generationConfig,
+      temperature: STRUCTURED_OUTPUT_TEMPERATURE
+    }).build();
+    return this.httpClient.postChatCompletion(request).then((response) => {
+      const content = this.extractContent(response.choices[0]?.message?.content);
+      return this.jsonParser.parse(content);
+    });
+  }
+  streamCompletion(prompt, callbacks, options = {}) {
+    return this.streamChatCompletion([createUserMessage(prompt)], callbacks, options);
+  }
+  /**
+   * Stream a chat completion given an existing message history.
+   * Resolves with the accumulated full text once the stream completes.
+   *
+   * @param messages - The full conversation history.
+   * @param callbacks - Streaming callbacks (`onChunk`, `onComplete`, `onError`).
+   * @param options - Generation options.
+   * @returns The full accumulated text.
+   */
+  async streamChatCompletion(messages, callbacks, options = {}) {
+    const model = options.model ?? DEFAULT_MODELS.TEXT;
+    const request = GroqChatRequestBuilder.for(model).withMessages(messages).withConfig(options.generationConfig).withStream(true).build();
+    const parser = new StreamingResponseParser({
+      onChunk: (chunk) => callbacks.onChunk?.(chunk)
+    });
+    try {
+      const stream = await this.httpClient.streamChatCompletion(request);
+      const fullText = await parser.parse(stream);
+      callbacks.onComplete?.(fullText);
+      return fullText;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      callbacks.onError?.(err);
+      throw err;
+    }
+  }
+  /**
+   * Clear the response cache (used by long-running services to free memory).
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  async executeWithCache(params, factory) {
+    const key = this.cache.generateKey(params);
+    const cached = this.cache.get(key);
+    if (cached !== null) {
+      return cached;
+    }
+    const result = await factory();
+    this.cache.set(key, result);
+    return result;
+  }
+  extractContent(content) {
+    if (!content) {
+      throw new GroqError(
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        "No content generated from Groq API"
+      );
+    }
+    return content;
+  }
+};
+
+// src/domains/groq/validators/api-key-validator.ts
+var DEFAULT_API_KEY_RULE = {
+  minLength: 10
+};
+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/domains/groq/clients/groq-config-store.ts
+var GroqConfigStore = class {
+  config = null;
+  /**
+   * Validate and persist the given config. Cancels any prior state
+   * by overwriting (callers that need atomicity should use `reset()` first).
+   *
+   * @throws GroqError with type `INVALID_API_KEY` if validation fails.
+   */
+  initialize(config) {
+    const validation = validateApiKey(config.apiKey);
+    if (!validation.valid) {
+      throw new GroqError("INVALID_API_KEY" /* INVALID_API_KEY */, validation.reason ?? "Invalid API key");
+    }
+    const normalized = {
+      apiKey: config.apiKey.trim(),
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      timeoutMs: config.timeoutMs ?? TIMEOUTS.DEFAULT,
+      ...config.textModel !== void 0 ? { textModel: config.textModel } : {}
+    };
+    this.config = normalized;
+    return normalized;
+  }
+  /**
+   * Returns the active config or throws if not initialized.
+   *
+   * @throws GroqError with type `MISSING_CONFIG` when not initialized.
+   */
+  get() {
+    if (!this.config) {
+      throw new GroqError(
+        "MISSING_CONFIG" /* MISSING_CONFIG */,
+        "Client not initialized. Call configureProvider first."
+      );
+    }
+    return this.config;
+  }
+  getOrNull() {
+    return this.config;
+  }
+  isInitialized() {
+    return this.config !== null;
+  }
+  /**
+   * Replace the API key.
+   *
+   * @throws GroqError with type `MISSING_CONFIG` if not initialized,
+   *         or `INVALID_API_KEY` if the new key fails validation.
+   */
+  setApiKey(apiKey) {
+    const current = this.get();
+    const validation = validateApiKey(apiKey);
+    if (!validation.valid) {
+      throw new GroqError("INVALID_API_KEY" /* INVALID_API_KEY */, validation.reason ?? "Invalid API key");
+    }
+    this.config = { ...current, apiKey: apiKey.trim() };
+  }
+  reset() {
+    this.config = null;
+  }
+};
+
+// src/domains/groq/validators/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/domains/groq/extractors/response-error-message-extractor.ts
+function extractErrorMessageFromJsonBody(body) {
+  if (!body || typeof body !== "object") return null;
+  const candidate = body;
+  const message = candidate.error?.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) {
+  try {
+    const body = await response.json();
+    const fromBody = extractErrorMessageFromJsonBody(body);
+    if (fromBody) return fromBody;
+  } catch {
+  }
+  return buildHttpStatusFallback(response.status, response.statusText);
+}
+
+// src/domains/groq/clients/groq-http-transport.ts
+var GroqHttpTransport = class {
+  constructor(configStore) {
+    this.configStore = configStore;
+  }
+  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) {
+    const config = this.configStore.get();
+    const url = `${config.baseUrl}${CHAT_COMPLETIONS_PATH}`;
+    const timeout = config.timeoutMs ?? TIMEOUTS.STREAMING;
+    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(config.apiKey),
+        body: JSON.stringify({ ...request, stream: true }),
+        signal: controller.signal
+      });
+      if (!response.ok) await this.throwFromErrorResponse(response);
+      if (!response.body) {
+        throw new GroqError("NETWORK_ERROR" /* NETWORK_ERROR */, "Response body is null");
+      }
+      return response.body;
+    } catch (error) {
+      throw this.normalizeError(error);
+    } finally {
+      clearTimeout(timeoutId);
+      this.pendingAbortControllers.delete(controller);
+    }
+  }
+  async request(endpoint, body) {
+    const config = this.configStore.get();
+    const url = `${config.baseUrl}${endpoint}`;
+    const timeout = config.timeoutMs ?? 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(config.apiKey),
+        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(apiKey) {
+    return {
+      [HTTP_HEADERS.CONTENT_TYPE]: HTTP_HEADERS.APPLICATION_JSON,
+      [HTTP_HEADERS.AUTHORIZATION]: `${HTTP_HEADERS.BEARER_PREFIX}${apiKey}`
+    };
+  }
+  async throwFromErrorResponse(response) {
+    const errorMessage = await extractErrorMessageFromResponse(response);
+    const metadata = {
+      status: response.status,
+      url: response.url
+    };
+    throw new GroqError(
+      classifyHttpStatus(response.status),
+      errorMessage,
+      void 0,
+      metadata
+    );
+  }
+  normalizeError(error) {
+    if (error instanceof GroqError) return error;
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new GroqError(
+          "ABORT_ERROR" /* ABORT_ERROR */,
+          "Request was aborted by the client",
+          error
+        );
+      }
+      if (error.name === "TypeError" && error.message.toLowerCase().includes("network")) {
+        return new GroqError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Network error: Unable to connect to Groq API",
+          error
+        );
+      }
+    }
+    return new GroqError(
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      error instanceof Error ? error.message : "Unknown error occurred",
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+
+// src/domains/groq/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.finally(() => {
+      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/domains/groq/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/domains/groq/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/domains/groq/validators/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);
+}
+
+// src/domains/groq/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 GroqError) {
+      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/domains/groq/strategies/retry-executor.strategy.ts
+var RetryExecutor = class {
+  constructor(retryManager2, options) {
+    this.retryManager = retryManager2;
+    this.options = options;
+  }
+  execute(fn, ...args) {
+    return this.retryManager.execute(() => fn(...args), this.options);
+  }
+};
+
+// src/domains/groq/strategies/queue-executor.strategy.ts
+var QueueExecutor = class {
+  constructor(queue, priority) {
+    this.queue = queue;
+    this.priority = priority;
+  }
+  execute(fn, ...args) {
+    return this.queue.add(() => fn(...args), this.priority);
+  }
+};
+
+// src/domains/groq/strategies/dedupe-executor.strategy.ts
+var DedupeExecutor = class {
+  constructor(deduplicator, options) {
+    this.deduplicator = deduplicator;
+    this.options = options;
+  }
+  execute(fn, ...args) {
+    const key = this.options.generateKey(...args);
+    return this.deduplicator.execute(key, () => fn(...args));
+  }
+};
+
+// src/domains/groq/strategies/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/domains/groq/clients/groq-http-client.ts
+var GroqHttpClient = class {
+  configStore;
+  transport;
+  executor;
+  constructor(deps = {}) {
+    this.configStore = deps.configStore ?? new GroqConfigStore();
+    this.transport = deps.transport ?? new GroqHttpTransport(this.configStore);
+    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,
+          this.configStore.get().apiKey
+        )
+      }),
+      new RetryExecutor(retryManager2),
+      new QueueExecutor(
+        queue,
+        QUEUE_PRIORITY_USER_REQUEST
+      )
+    ]);
+  }
+  initialize(config) {
+    this.configStore.initialize(config);
+  }
+  cancelPendingRequests() {
+    this.transport.cancelPendingRequests();
+  }
+  isInitialized() {
+    return this.configStore.isInitialized();
+  }
+  getApiKey() {
+    return this.configStore.get().apiKey;
+  }
+  setApiKey(apiKey) {
+    this.configStore.setApiKey(apiKey);
+  }
+  postChatCompletion(request) {
+    return this.executor.execute(
+      (req) => this.transport.postChatCompletion(req),
+      request
+    );
+  }
+  streamChatCompletion(request) {
+    return this.transport.streamChatCompletion(request);
+  }
+  reset() {
+    this.transport.cancelPendingRequests();
+    this.configStore.reset();
+  }
+};
+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/domains/groq/resolvers/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 GroqError) {
+    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/domains/groq/utils/error-resolver.ts
+var resolveUserFriendlyMessage = resolveUserFriendlyErrorMessage;
+function formatErrorForLogging(error) {
+  if (error instanceof GroqError) {
+    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/domains/groq/hooks/use-groq.hook.ts
+function useGroq(options = {}, deps) {
+  const textGeneration = deps?.textGeneration;
+  if (!textGeneration) {
+    throw new Error(
+      "useGroq requires a TextGenerationService dependency. Provide it via the second argument or wire it through the app container."
+    );
+  }
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [result, setResult] = react.useState(null);
+  const optionsRef = react.useRef(options);
+  optionsRef.current = options;
+  const abortControllerRef = react.useRef(null);
+  const stableConfig = react.useMemo(
+    () => ({
+      model: options.model,
+      generationConfig: options.generationConfig
+    }),
+    [
+      options.model,
+      options.generationConfig?.temperature,
+      options.generationConfig?.maxTokens,
+      options.generationConfig?.topP
+    ]
+  );
+  react.useEffect(() => {
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+    return () => {
+      controller.abort();
+      abortControllerRef.current = null;
+    };
+  }, []);
+  const runWithState = react.useCallback(
+    async (task) => {
+      const controller = abortControllerRef.current;
+      if (!controller) {
+        return null;
+      }
+      const { signal } = controller;
+      if (signal.aborted) return null;
+      setIsLoading(true);
+      setError(null);
+      setResult(null);
+      const currentOptions = optionsRef.current;
+      currentOptions.onStart?.();
+      try {
+        const value = await task(signal);
+        return value;
+      } catch (err) {
+        if (signal.aborted) {
+          return null;
+        }
+        const message = resolveUserFriendlyMessage(err);
+        setError(message);
+        currentOptions.onError?.(message);
+        throw err;
+      } finally {
+        if (!signal.aborted) {
+          setIsLoading(false);
+        }
+      }
+    },
+    []
+  );
+  const generate = react.useCallback(
+    (prompt, config) => runWithState(async () => {
+      const response = await textGeneration.generateCompletion(prompt, {
+        model: stableConfig.model,
+        generationConfig: {
+          ...stableConfig.generationConfig,
+          ...config
+        }
+      });
+      setResult(response);
+      optionsRef.current.onSuccess?.(response);
+      return response;
+    }),
+    [runWithState, textGeneration, stableConfig]
+  );
+  const generateJSON = react.useCallback(
+    (prompt, config) => runWithState(async () => {
+      const response = await textGeneration.generateStructured(prompt, {
+        model: stableConfig.model,
+        generationConfig: {
+          ...stableConfig.generationConfig,
+          ...config
+        },
+        ...config?.schema !== void 0 ? { schema: config.schema } : {}
+      });
+      const json = JSON.stringify(response, null, 2);
+      setResult(json);
+      optionsRef.current.onSuccess?.(json);
+      return response;
+    }),
+    [runWithState, textGeneration, stableConfig]
+  );
+  const stream = react.useCallback(
+    (prompt, onChunk, config) => runWithState(async () => {
+      const callbacks = {
+        onChunk,
+        onComplete: (text) => {
+          setResult(text);
+          optionsRef.current.onSuccess?.(text);
+        }
+      };
+      return textGeneration.streamCompletion(
+        prompt,
+        callbacks,
+        {
+          model: stableConfig.model,
+          generationConfig: {
+            ...stableConfig.generationConfig,
+            ...config
+          }
+        }
+      );
+    }),
+    [runWithState, textGeneration, stableConfig]
+  );
+  const cancel = react.useCallback(() => {
+    abortControllerRef.current?.abort();
+    setIsLoading(false);
+  }, []);
+  const reset = react.useCallback(() => {
+    cancel();
+    setError(null);
+    setResult(null);
+  }, [cancel]);
+  const clearError = react.useCallback(() => setError(null), []);
+  return {
+    isLoading,
+    error,
+    result,
+    generate,
+    generateJSON,
+    stream,
+    cancel,
+    reset,
+    clearError
+  };
+}
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+function useCacheStats(cache, options = {}) {
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const enabled = options.enabled ?? true;
+  const [snapshot, setSnapshot] = react.useState(() => cache.getStats());
+  react.useEffect(() => {
+    if (!enabled) return;
+    setSnapshot(cache.getStats());
+    const intervalId = setInterval(() => {
+      setSnapshot(cache.getStats());
+    }, pollIntervalMs);
+    return () => clearInterval(intervalId);
+  }, [cache, pollIntervalMs, enabled]);
+  return snapshot;
+}
+
+// src/domains/groq/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/domains/groq/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 });
+}
+
+exports.API_ENDPOINTS = API_ENDPOINTS;
+exports.CacheManager = CacheManager;
+exports.CompositeExecutor = CompositeExecutor;
+exports.DEFAULT_BASE_URL = DEFAULT_BASE_URL;
+exports.DEFAULT_GENERATION_CONFIG = DEFAULT_GENERATION_CONFIG;
+exports.DEFAULT_MODELS = DEFAULT_MODELS;
+exports.DedupeExecutor = DedupeExecutor;
+exports.GROQ_MODELS = GROQ_MODELS;
+exports.GroqChatRequestBuilder = GroqChatRequestBuilder;
+exports.GroqConfigStore = GroqConfigStore;
+exports.GroqError = GroqError;
+exports.GroqErrorType = GroqErrorType;
+exports.GroqHttpClient = GroqHttpClient;
+exports.GroqHttpTransport = GroqHttpTransport;
+exports.JsonResponseParser = JsonResponseParser;
+exports.QueueExecutor = QueueExecutor;
+exports.RequestDeduplicator = RequestDeduplicator;
+exports.RequestQueue = RequestQueue;
+exports.RetryExecutor = RetryExecutor;
+exports.RetryManager = RetryManager;
+exports.StreamingResponseParser = StreamingResponseParser;
+exports.StructuredPromptBuilder = StructuredPromptBuilder;
+exports.TIMEOUTS = TIMEOUTS;
+exports.TextGenerationService = TextGenerationService;
+exports.USER_FRIENDLY_ERROR_MESSAGES = USER_FRIENDLY_ERROR_MESSAGES;
+exports.cacheManager = cacheManager;
+exports.createAssistantMessage = createAssistantMessage;
+exports.createMessage = createMessage;
+exports.createSystemMessage = createSystemMessage;
+exports.createUserMessage = createUserMessage;
+exports.debounce = debounce;
+exports.debounceManager = debounceManager;
+exports.extractTextFromMessages = extractTextFromMessages;
+exports.formatErrorForLogging = formatErrorForLogging;
+exports.formatMessagesForDisplay = formatMessagesForDisplay;
+exports.promptToMessages = promptToMessages;
+exports.requestDeduplicator = requestDeduplicator;
+exports.requestQueue = requestQueue;
+exports.resolveUserFriendlyMessage = resolveUserFriendlyMessage;
+exports.retryManager = retryManager;
+exports.throttle = throttle;
+exports.throttleManager = throttleManager;
+exports.useCacheStats = useCacheStats;
+exports.useGroq = useGroq;
+exports.withRetry = withRetry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map