@umituz/react-native-ai-groq-provider 1.0.21 → 1.0.22

package/src/infrastructure/services/ChatSession.ts

@@ -1,316 +0,0 @@
-/**
- * Chat Session Service
- * Manages multi-turn chat conversations with Groq API
- */
-
-import type {
-  GroqMessage,
-  GroqChatConfig,
-  GroqGenerationConfig,
-} from "../../domain/entities";
-import { groqHttpClient } from "./GroqClient";
-import { DEFAULT_MODELS } from "../../domain/entities";
-import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
-import { generateSessionId, calculateMaxMessages } from "../../infrastructure/utils/calculation.util";
-
-/**
- * Chat session state
- */
-export interface ChatSession {
-  id: string;
-  model: string;
-  systemInstruction?: string;
-  messages: GroqMessage[];
-  generationConfig?: GroqGenerationConfig;
-  createdAt: Date;
-  updatedAt: Date;
-}
-
-/**
- * Result of sending a chat message
- */
-export interface ChatSendResult {
-  response: string;
-  usage: {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-  };
-  finishReason: string;
-}
-
-/**
- * Options for sending a chat message
- */
-export interface SendChatMessageOptions {
-  /** Stream the response (not yet implemented) */
-  stream?: boolean;
-}
-
-/**
- * Message format for chat history (simplified)
- */
-export type ChatHistoryMessage = {
-  role: "system" | "user" | "assistant";
-  content: string;
-};
-
-/**
- * Create a new chat session
- */
-export function createChatSession(config: GroqChatConfig = {}): ChatSession {
-  return {
-    id: generateSessionId("groq-chat"),
-    model: config.model || DEFAULT_MODELS.TEXT,
-    systemInstruction: config.systemInstruction,
-    messages: config.history ? [...config.history] : [],
-    generationConfig: config.generationConfig,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  };
-}
-
-/**
- * Chat session service
- */
-class ChatSessionService {
-  private sessions = new Map<string, ChatSession>();
-  private readonly MAX_SESSIONS = 100; // Prevent unlimited memory growth
-  private readonly SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
-
-  /**
-   * Create a new chat session
-   */
-  create(config: GroqChatConfig = {}): ChatSession {
-    // Auto-cleanup old sessions before creating new one
-    this.cleanupOldSessions();
-
-    const session = createChatSession(config);
-    this.sessions.set(session.id, session);
-
-    // Enforce session limit
-    if (this.sessions.size > this.MAX_SESSIONS) {
-      // Remove oldest sessions
-      const sortedSessions = Array.from(this.sessions.entries())
-        .sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
-
-      const toRemove = sortedSessions.slice(0, this.sessions.size - this.MAX_SESSIONS);
-      for (const [id] of toRemove) {
-        this.sessions.delete(id);
-      }
-    }
-
-    return session;
-  }
-
-  /**
-   * Get a session by ID
-   */
-  get(sessionId: string): ChatSession | undefined {
-    return this.sessions.get(sessionId);
-  }
-
-  /**
-   * Delete a session
-   */
-  delete(sessionId: string): boolean {
-    return this.sessions.delete(sessionId);
-  }
-
-  /**
-   * Cleanup old sessions automatically
-   */
-  private cleanupOldSessions(): void {
-    const now = Date.now();
-    const expiredIds: string[] = [];
-
-    for (const [id, session] of this.sessions.entries()) {
-      const age = now - session.updatedAt.getTime();
-      if (age > this.SESSION_TTL_MS) {
-        expiredIds.push(id);
-      }
-    }
-
-    for (const id of expiredIds) {
-      this.sessions.delete(id);
-    }
-  }
-
-  /**
-   * Get active session count
-   */
-  getActiveCount(): number {
-    return this.sessions.size;
-  }
-
-  /**
-   * Clear all sessions
-   */
-  clearAll(): void {
-    this.sessions.clear();
-  }
-
-  /**
-   * Send a message in a chat session
-   */
-  async send(
-    sessionId: string,
-    content: string,
-    _options: SendChatMessageOptions = {}
-  ): Promise<ChatSendResult> {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        `Chat session ${sessionId} not found`
-      );
-    }
-
-    // Add user message to history
-    const userMessage: GroqMessage = {
-      role: "user",
-      content,
-    };
-    session.messages.push(userMessage);
-
-    // Build messages array for API
-    const messagesForApi = buildChatHistory(session);
-
-    // Call API
-    const response = await groqHttpClient.chatCompletion({
-      model: session.model,
-      messages: messagesForApi,
-      temperature: session.generationConfig?.temperature || 0.7,
-      max_tokens: session.generationConfig?.maxTokens || 1024,
-      top_p: session.generationConfig?.topP,
-    });
-
-    // Extract assistant response
-    const assistantContent = response.choices[0]?.message?.content;
-    if (!assistantContent) {
-      throw new GroqError(
-        GroqErrorType.UNKNOWN_ERROR,
-        "No content generated from Groq API"
-      );
-    }
-
-    // Add assistant message to history
-    const assistantMessage: GroqMessage = {
-      role: "assistant",
-      content: assistantContent,
-    };
-    session.messages.push(assistantMessage);
-
-    // Update timestamp
-    session.updatedAt = new Date();
-
-    return {
-      response: assistantContent,
-      usage: {
-        promptTokens: response.usage?.prompt_tokens || 0,
-        completionTokens: response.usage?.completion_tokens || 0,
-        totalTokens: response.usage?.total_tokens || 0,
-      },
-      finishReason: response.choices[0]?.finish_reason || "unknown",
-    };
-  }
-
-  /**
-   * Reset a chat session (clear messages except system instruction)
-   */
-  reset(sessionId: string): ChatSession {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        `Chat session ${sessionId} not found`
-      );
-    }
-
-    session.messages = [];
-    session.updatedAt = new Date();
-
-    return session;
-  }
-
-  /**
-   * Update a chat session's config
-   */
-  updateConfig(sessionId: string, config: Partial<GroqChatConfig>): ChatSession {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        `Chat session ${sessionId} not found`
-      );
-    }
-
-    if (config.model !== undefined) session.model = config.model;
-    if (config.systemInstruction !== undefined) session.systemInstruction = config.systemInstruction;
-    if (config.generationConfig !== undefined) session.generationConfig = config.generationConfig;
-    if (config.history) session.messages = [...config.history];
-
-    session.updatedAt = new Date();
-
-    return session;
-  }
-}
-
-/**
- * Singleton instance
- */
-export const chatSessionService = new ChatSessionService();
-
-/**
- * Convenience function to send a chat message
- */
-export async function sendChatMessage(
-  sessionId: string,
-  content: string,
-  options?: SendChatMessageOptions
-): Promise<ChatSendResult> {
-  return chatSessionService.send(sessionId, content, options);
-}
-
-/**
- * Build chat history for API request
- */
-export function buildChatHistory(session: ChatSession): GroqMessage[] {
-  const messages: GroqMessage[] = [];
-
-  // Add system instruction if present
-  if (session.systemInstruction) {
-    messages.push({
-      role: "system",
-      content: session.systemInstruction,
-    });
-  }
-
-  // Add conversation history
-  messages.push(...session.messages);
-
-  return messages;
-}
-
-/**
- * Trim chat history to fit within token limit
- */
-export function trimChatHistory(
-  messages: GroqMessage[],
-  maxTokens: number = 4000
-): GroqMessage[] {
-  // Calculate max messages using utility function
-  const maxMessages = calculateMaxMessages(maxTokens);
-
-  if (messages.length <= maxMessages) {
-    return messages;
-  }
-
-  // Keep system messages and trim from oldest to newest
-  const systemMessages = messages.filter((m) => m.role === "system");
-  const nonSystemMessages = messages.filter((m) => m.role !== "system");
-
-  const trimmed = nonSystemMessages.slice(-maxMessages);
-
-  return [...systemMessages, ...trimmed];
-}

package/src/infrastructure/services/GroqClient.ts

@@ -1,351 +0,0 @@
-/**
- * Groq HTTP Client
- * Handles all HTTP communication with Groq API
- */
-
-import type {
-  GroqConfig,
-  GroqChatRequest,
-  GroqChatResponse,
-  GroqChatChunk,
-} from "../../domain/entities";
-import { GroqError, GroqErrorType, mapHttpStatusToErrorType } from "../../domain/entities/error.types";
-import { calculateSafeBufferSize } from "../../infrastructure/utils/calculation.util";
-
-const DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
-const DEFAULT_TIMEOUT = 60000; // 60 seconds
-const CHAT_COMPLETIONS_ENDPOINT = "/chat/completions";
-
-class GroqHttpClient {
-  private config: GroqConfig | null = null;
-  private initialized = false;
-
-  /**
-   * Initialize the client with configuration
-   */
-  initialize(config: GroqConfig): void {
-    const apiKey = config.apiKey?.trim();
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GroqClient] Initializing:", {
-        hasApiKey: !!apiKey,
-        keyLength: apiKey?.length,
-        keyPrefix: apiKey ? apiKey.substring(0, 10) + "..." : "",
-        baseUrl: config.baseUrl || DEFAULT_BASE_URL,
-        timeoutMs: config.timeoutMs || DEFAULT_TIMEOUT,
-        textModel: config.textModel,
-      });
-    }
-
-    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 || DEFAULT_TIMEOUT,
-      textModel: config.textModel,
-    };
-    this.initialized = true;
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GroqClient] Initialization complete:", {
-        initialized: this.initialized,
-        baseUrl: this.config.baseUrl,
-      });
-    }
-  }
-
-  /**
-   * Check if client is initialized
-   */
-  isInitialized(): boolean {
-    return this.initialized && this.config !== null;
-  }
-
-  /**
-   * Get current configuration
-   */
-  getConfig(): GroqConfig {
-    if (!this.config || !this.initialized) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        "Client not initialized. Call initialize() first."
-      );
-    }
-    return this.config;
-  }
-
-  /**
-   * Make an HTTP request to Groq API
-   */
-  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 || DEFAULT_TIMEOUT;
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GroqClient] API Request:", {
-        url,
-        endpoint,
-        method: "POST",
-        timeout: `${timeout}ms`,
-        hasBody: !!body,
-        bodyKeys: body ? Object.keys(body) : [],
-      });
-    }
-
-    try {
-      // Create AbortController for timeout
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-      // Use provided signal if available
-      if (signal) {
-        signal.addEventListener("abort", () => controller.abort());
-      }
-
-      const fetchStartTime = Date.now();
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${this.config.apiKey}`,
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      });
-
-      const fetchDuration = Date.now() - fetchStartTime;
-      clearTimeout(timeoutId);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[GroqClient] API Response:", {
-          status: response.status,
-          ok: response.ok,
-          fetchDuration: `${fetchDuration}ms`,
-          contentType: response.headers.get("content-type"),
-        });
-      }
-
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-
-      const jsonStart = Date.now();
-      const jsonData = (await response.json()) as T;
-      const parseDuration = Date.now() - jsonStart;
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[GroqClient] JSON parsed:", {
-          parseDuration: `${parseDuration}ms`,
-          hasData: !!jsonData,
-          dataKeys: jsonData ? Object.keys(jsonData) : [],
-        });
-      }
-
-      return jsonData;
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[GroqClient] Request error:", {
-          error,
-          errorMessage: error instanceof Error ? error.message : String(error),
-          errorName: error instanceof Error ? error.name : undefined,
-        });
-      }
-
-      throw this.handleRequestError(error);
-    }
-  }
-
-  /**
-   * Handle HTTP error responses
-   */
-  private async handleErrorResponse(response: Response): Promise<never> {
-    let errorMessage = `HTTP ${response.status}`;
-    let 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, {
-      status: response.status,
-      url: response.url,
-    });
-  }
-
-  /**
-   * Handle request errors (network, timeout, abort)
-   */
-  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
-    );
-  }
-
-  /**
-   * Send chat completion request (non-streaming)
-   */
-  async chatCompletion(
-    request: GroqChatRequest,
-    signal?: AbortSignal
-  ): Promise<GroqChatResponse> {
-    return this.request<GroqChatResponse>(
-      CHAT_COMPLETIONS_ENDPOINT,
-      { ...request, stream: false },
-      signal
-    );
-  }
-
-  /**
-   * Send chat completion request (streaming)
-   * Returns an async generator of chunks
-   */
-  async *chatCompletionStream(
-    request: GroqChatRequest,
-    signal?: AbortSignal
-  ): AsyncGenerator<GroqChatChunk> {
-    if (!this.config || !this.initialized) {
-      throw new GroqError(
-        GroqErrorType.MISSING_CONFIG,
-        "Client not initialized. Call initialize() first."
-      );
-    }
-
-    const url = `${this.config.baseUrl}${CHAT_COMPLETIONS_ENDPOINT}`;
-    const timeout = this.config.timeoutMs || DEFAULT_TIMEOUT;
-
-    // Create AbortController for timeout
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-    // Use provided signal if available
-    if (signal) {
-      signal.addEventListener("abort", () => controller.abort());
-    }
-
-    try {
-      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,
-      });
-
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-
-      if (!response.body) {
-        throw new GroqError(
-          GroqErrorType.NETWORK_ERROR,
-          "Response body is null"
-        );
-      }
-
-      // Read and parse Server-Sent Events
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB max buffer to prevent memory issues
-
-      while (true) {
-        const { done, value } = await reader.read();
-
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-
-        // Prevent unlimited buffer growth using utility function
-        const safeSize = calculateSafeBufferSize(buffer.length, MAX_BUFFER_SIZE);
-        if (safeSize < buffer.length) {
-          buffer = buffer.slice(-safeSize);
-        }
-
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed === "data: [DONE]") continue;
-
-          if (trimmed.startsWith("data: ")) {
-            const jsonStr = trimmed.slice(6);
-            try {
-              const chunk = JSON.parse(jsonStr) as GroqChatChunk;
-              yield chunk;
-            } catch (error) {
-              if (typeof __DEV__ !== "undefined" && __DEV__) {
-                console.error("Failed to parse SSE chunk:", error);
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      throw this.handleRequestError(error);
-    }
-  }
-
-  /**
-   * Reset the client
-   */
-  reset(): void {
-    this.config = null;
-    this.initialized = false;
-  }
-}
-
-/**
- * Singleton instance
- */
-export const groqHttpClient = new GroqHttpClient();