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

package/src/domains/groq/interfaces/index.ts

@@ -1,22 +0,0 @@
-/**
- * Domain Interfaces Index
- * Subpath: @umituz/web-ai-groq-provider/domain
- */
-
-export type {
-  TextGenerationOptions,
-  StreamingCallbacks,
-  StructuredGenerationOptions,
-} from "./groq.interface";
-
-export type { IGroqChatService, IGroqHttpClient } from "./groq.interface";
-
-// Re-export from entities for convenience
-export type {
-  GroqConfig,
-  GroqGenerationConfig,
-  GroqMessage,
-  GroqChatRequest,
-  GroqChatResponse,
-  GroqChatChunk,
-} from "../entities";

package/src/domains/groq/services/http-client.service.ts

@@ -1,265 +0,0 @@
-/**
- * Groq HTTP Client Service
- * @description Handles all HTTP communication with Groq API with performance optimizations
- */
-
-import type { IGroqHttpClient } from "../interfaces";
-import type { GroqConfig, GroqChatRequest, GroqChatResponse } from "../entities";
-import { GroqError } from "../utils/groq-error.util";
-import { GroqErrorType, mapHttpStatusToErrorType } from "../constants/error.constants";
-import { DEFAULT_BASE_URL, TIMEOUTS } from "../constants/groq.constants";
-import { requestDeduplicator } from "../utils/request-deduplicator.util";
-import { requestQueue } from "../utils/request-queue.util";
-import { retryManager } from "../utils/retry.util";
-
-class GroqHttpClientService implements IGroqHttpClient {
-  private config: GroqConfig | null = null;
-  private initialized = false;
-  private pendingAbortControllers = new Set<AbortController>();
-
-  initialize(config: GroqConfig): void {
-    const apiKey = config.apiKey?.trim();
-
-    if (!apiKey || apiKey.length < 10) {
-      throw new GroqError(
-        GroqErrorType.INVALID_API_KEY,
-        "API key is required and must be at least 10 characters"
-      );
-    }
-
-    this.config = {
-      apiKey,
-      baseUrl: config.baseUrl || DEFAULT_BASE_URL,
-      timeoutMs: config.timeoutMs || TIMEOUTS.DEFAULT,
-      textModel: config.textModel,
-    };
-    this.initialized = true;
-  }
-
-  /**
-   * Cancel all pending requests
-   */
-  cancelPendingRequests(): void {
-    for (const controller of this.pendingAbortControllers) {
-      controller.abort();
-    }
-    this.pendingAbortControllers.clear();
-    requestQueue.cancelAll();
-    requestDeduplicator.cancelAll();
-  }
-
-  isInitialized(): boolean {
-    return this.initialized && this.config !== null;
-  }
-
-  getApiKey(): string {
-    if (!this.config) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        "Client not initialized"
-      );
-    }
-    return this.config.apiKey;
-  }
-
-  setApiKey(apiKey: string): void {
-    if (!this.config) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        "Client not initialized. Call initialize() first."
-      );
-    }
-    this.config = { ...this.config, apiKey: apiKey.trim() };
-  }
-
-  async postChatCompletion(request: GroqChatRequest): Promise<GroqChatResponse> {
-    // Generate deduplication key
-    const dedupeKey = requestDeduplicator.generateKey({
-      endpoint: "/chat/completions",
-      ...request,
-    });
-
-    // Execute with deduplication, retry, and queue management
-    return requestDeduplicator.execute(dedupeKey, () =>
-      retryManager.execute(() =>
-        requestQueue.add(
-          () => this.request<GroqChatResponse>("/chat/completions", { ...request, stream: false }),
-          10 // High priority for user-initiated requests
-        )
-      )
-    );
-  }
-
-  async streamChatCompletion(request: GroqChatRequest): Promise<ReadableStream> {
-    if (!this.config || !this.initialized) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        "Client not initialized. Call initialize() first."
-      );
-    }
-
-    const url = `${this.config.baseUrl}/chat/completions`;
-    const timeout = this.config.timeoutMs || TIMEOUTS.STREAMING;
-
-    let controller: AbortController | null = null;
-    let timeoutId: NodeJS.Timeout | null = null;
-
-    try {
-      controller = new AbortController();
-      timeoutId = setTimeout(() => controller?.abort(), timeout);
-
-      this.pendingAbortControllers.add(controller);
-
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`,
-        },
-        body: JSON.stringify({ ...request, stream: true }),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        throw new GroqError(
-          mapHttpStatusToErrorType(response.status),
-          `HTTP ${response.status}: ${response.statusText}`,
-          undefined,
-          { status: response.status, url: response.url }
-        );
-      }
-
-      if (!response.body) {
-        throw new GroqError(
-          GroqErrorType.NETWORK_ERROR,
-          "Response body is null"
-        );
-      }
-
-      return response.body;
-    } catch (error) {
-      throw this.handleRequestError(error);
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (controller) {
-        this.pendingAbortControllers.delete(controller);
-      }
-    }
-  }
-
-  private async request<T>(
-    endpoint: string,
-    body: unknown,
-    signal?: AbortSignal
-  ): Promise<T> {
-    if (!this.config || !this.initialized) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        "Client not initialized. Call initialize() first."
-      );
-    }
-
-    const url = `${this.config.baseUrl}${endpoint}`;
-    const timeout = this.config.timeoutMs || TIMEOUTS.DEFAULT;
-
-    let controller: AbortController | null = null;
-    let timeoutId: NodeJS.Timeout | null = null;
-
-    try {
-      controller = new AbortController();
-      timeoutId = setTimeout(() => controller?.abort(), timeout);
-
-      if (signal) {
-        signal.addEventListener("abort", () => controller?.abort());
-      }
-
-      this.pendingAbortControllers.add(controller);
-
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${this.config.apiKey}`,
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-
-      return (await response.json()) as T;
-    } catch (error) {
-      throw this.handleRequestError(error);
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (controller) {
-        this.pendingAbortControllers.delete(controller);
-      }
-    }
-  }
-
-  private async handleErrorResponse(response: Response): Promise<never> {
-    let errorMessage = `HTTP ${response.status}`;
-    const errorType = mapHttpStatusToErrorType(response.status);
-
-    try {
-      const errorData = (await response.json()) as {
-        error?: { message?: string };
-      };
-      if (errorData.error?.message) {
-        errorMessage = errorData.error.message;
-      }
-    } catch {
-      // If parsing fails, use default message
-    }
-
-    throw new GroqError(errorType, errorMessage, undefined, {
-      status: response.status,
-      url: response.url,
-    });
-  }
-
-  private handleRequestError(error: unknown): GroqError {
-    if (error instanceof GroqError) {
-      return error;
-    }
-
-    if (error instanceof Error) {
-      if (error.name === "AbortError") {
-        return new GroqError(
-          GroqErrorType.ABORT_ERROR,
-          "Request was aborted by the client",
-          error
-        );
-      }
-
-      if (error.name === "TypeError" && error.message.includes("network")) {
-        return new GroqError(
-          GroqErrorType.NETWORK_ERROR,
-          "Network error: Unable to connect to Groq API",
-          error
-        );
-      }
-    }
-
-    return new GroqError(
-      GroqErrorType.UNKNOWN_ERROR,
-      error instanceof Error ? error.message : "Unknown error occurred",
-      error as Error
-    );
-  }
-
-  reset(): void {
-    this.cancelPendingRequests();
-    this.config = null;
-    this.initialized = false;
-  }
-}
-
-export const groqHttpClient = new GroqHttpClientService();

package/src/domains/groq/services/index.ts

@@ -1,9 +0,0 @@
-/**
- * Infrastructure Services Index
- * Subpath: @umituz/web-ai-groq-provider/services
- */
-
-export { groqHttpClient } from "./http-client.service";
-export { textGenerationService } from "./text-generation.service";
-export type { IGroqHttpClient } from "../interfaces";
-export type { IGroqChatService } from "../interfaces";

package/src/domains/groq/services/text-generation.service.ts

@@ -1,238 +0,0 @@
-/**
- * Text Generation Service
- * @description Handles text generation using Groq API with caching and performance optimizations
- */
-
-import type { IGroqChatService } from "../interfaces";
-import type {
-  GroqMessage,
-  GroqChatRequest,
-  TextGenerationOptions,
-  StreamingCallbacks,
-  StructuredGenerationOptions,
-} from "../interfaces";
-import { groqHttpClient } from "./http-client.service";
-import { GroqError } from "../utils/groq-error.util";
-import { GroqErrorType } from "../constants/error.constants";
-import { DEFAULT_MODELS, DEFAULT_GENERATION_CONFIG } from "../constants/groq.constants";
-import { cacheManager } from "../utils/cache-manager.util";
-
-class TextGenerationService implements IGroqChatService {
-  private readonly CACHE_TTL = 300000; // 5 minutes
-  async generateCompletion(
-    prompt: string,
-    options: TextGenerationOptions = {}
-  ): Promise<string> {
-    const model = options.model || DEFAULT_MODELS.TEXT;
-
-    // Check cache first
-    const cacheKey = cacheManager.generateKey({
-      type: "completion",
-      model,
-      prompt,
-      config: options.generationConfig,
-    });
-
-    const cached = cacheManager.get<string>(cacheKey);
-    if (cached !== null) {
-      return cached;
-    }
-
-    const messages: GroqMessage[] = [{ role: "user", content: prompt }];
-    const request = this.buildRequest(model, messages, options.generationConfig);
-
-    const response = await groqHttpClient.postChatCompletion(request);
-    const content = response.choices[0]?.message?.content;
-
-    if (!content) {
-      throw new GroqError(
-        GroqErrorType.UNKNOWN_ERROR,
-        "No content generated from Groq API"
-      );
-    }
-
-    // Cache the result
-    cacheManager.set(cacheKey, content);
-
-    return content;
-  }
-
-  async generateChatCompletion(
-    messages: GroqMessage[],
-    options: TextGenerationOptions = {}
-  ): Promise<string> {
-    const model = options.model || DEFAULT_MODELS.TEXT;
-
-    // Check cache first
-    const cacheKey = cacheManager.generateKey({
-      type: "chat",
-      model,
-      messages,
-      config: options.generationConfig,
-    });
-
-    const cached = cacheManager.get<string>(cacheKey);
-    if (cached !== null) {
-      return cached;
-    }
-
-    const request = this.buildRequest(model, messages, options.generationConfig);
-    const response = await groqHttpClient.postChatCompletion(request);
-    const content = response.choices[0]?.message?.content;
-
-    if (!content) {
-      throw new GroqError(
-        GroqErrorType.UNKNOWN_ERROR,
-        "No content generated from Groq API"
-      );
-    }
-
-    // Cache the result
-    cacheManager.set(cacheKey, content);
-
-    return content;
-  }
-
-  async generateStructured<T>(
-    prompt: string,
-    options: StructuredGenerationOptions = {}
-  ): Promise<T> {
-    const model = options.model || DEFAULT_MODELS.TEXT;
-
-    // Build JSON prompt
-    const jsonPrompt = this.buildStructuredPrompt(prompt, options.schema);
-    const messages: GroqMessage[] = [{ role: "user", content: jsonPrompt }];
-    const request = this.buildRequest(model, messages, {
-      ...options.generationConfig,
-      temperature: 0.1, // Lower temperature for structured output
-    });
-
-    const response = await groqHttpClient.postChatCompletion(request);
-    const content = response.choices[0]?.message?.content;
-
-    if (!content) {
-      throw new GroqError(
-        GroqErrorType.UNKNOWN_ERROR,
-        "No content generated from Groq API"
-      );
-    }
-
-    // Parse JSON response
-    try {
-      const jsonMatch = content.match(/```json\n([\s\S]*?)\n```/) ||
-                      content.match(/\{[\s\S]*\}/);
-      const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : content;
-      const parsed = JSON.parse(jsonStr) as T;
-
-      return parsed;
-    } catch (error) {
-      throw new GroqError(
-        GroqErrorType.UNKNOWN_ERROR,
-        "Failed to parse structured response as JSON",
-        error as Error
-      );
-    }
-  }
-
-  async streamCompletion(
-    prompt: string,
-    callbacks: StreamingCallbacks,
-    options: TextGenerationOptions = {}
-  ): Promise<void> {
-    const model = options.model || DEFAULT_MODELS.TEXT;
-    const messages: GroqMessage[] = [{ role: "user", content: prompt }];
-    const request = this.buildRequest(model, messages, options.generationConfig);
-
-    try {
-      const stream = await groqHttpClient.streamChatCompletion(request);
-      const reader = stream.getReader();
-      const decoder = new TextDecoder();
-      const contentChunks: string[] = []; // Use array instead of string concatenation
-
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        const chunk = decoder.decode(value, { stream: true }); // Optimize with stream option
-        const lines = chunk.split("\n").filter(line => line.trim() !== "");
-
-        for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6);
-            if (data === "[DONE]") continue;
-
-            try {
-              const parsed = JSON.parse(data) as {
-                choices?: Array<{ delta?: { content?: string } }>;
-              };
-              const content = parsed.choices?.[0]?.delta?.content;
-              if (content) {
-                contentChunks.push(content); // Push to array instead of concatenation
-                callbacks.onChunk?.(content);
-              }
-            } catch {
-              // Skip invalid JSON chunks
-            }
-          }
-        }
-      }
-
-      // Join chunks at the end - more efficient than repeated concatenation
-      const fullContent = contentChunks.join('');
-      callbacks.onComplete?.(fullContent);
-    } catch (error) {
-      callbacks.onError?.(error as Error);
-      throw error;
-    }
-  }
-
-  private buildRequest(
-    model: string,
-    messages: GroqMessage[],
-    config?: TextGenerationOptions["generationConfig"]
-  ): GroqChatRequest {
-    return {
-      model,
-      messages,
-      temperature: config?.temperature ?? DEFAULT_GENERATION_CONFIG.temperature,
-      max_tokens: config?.maxTokens ?? DEFAULT_GENERATION_CONFIG.maxTokens,
-      top_p: config?.topP ?? DEFAULT_GENERATION_CONFIG.topP,
-      n: config?.n,
-      stop: config?.stop,
-      frequency_penalty: config?.frequencyPenalty,
-      presence_penalty: config?.presencePenalty,
-    };
-  }
-
-  private buildStructuredPrompt(
-    prompt: string,
-    schema?: Record<string, unknown>
-  ): string {
-    let structuredPrompt = `Please generate a JSON response for the following request.\n\n`;
-
-    if (schema) {
-      structuredPrompt += `Expected JSON schema:\n${JSON.stringify(schema, null, 2)}\n\n`;
-    }
-
-    structuredPrompt += `Request:\n${prompt}\n\n`;
-    structuredPrompt += `Respond only with valid JSON, formatted as:\n\`\`\`json\n{...}\n\`\`\``;
-
-    return structuredPrompt;
-  }
-}
-
-export const textGenerationService = new TextGenerationService();
-
-/**
- * Clear all cached responses
- */
-export function clearGenerationCache(): void {
-  cacheManager.clear();
-}
-
-/**
- * Get cache statistics
- */
-export function getCacheStats() {
-  return cacheManager.getStats();
-}