@umituz/react-native-ai-groq-provider 1.0.24 → 1.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-groq-provider",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "Groq text generation provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",

package/src/application/use-cases/chat-session.usecase.ts

@@ -3,13 +3,14 @@
  * Manages multi-turn chat conversations
  */
 
-import type { GroqMessage, GroqChatConfig } from "../../domain/entities";
-import { groqHttpClient } from "../../infrastructure/http";
+import type { GroqMessage, GroqChatConfig } from "../../domain/entities/groq.types";
+import { DEFAULT_MODELS } from "../../domain/entities/groq.types";
+import { groqHttpClient } from "../../infrastructure/http/groq-http-client";
 import { RequestBuilder } from "../../shared/request-builder";
 import { ResponseHandler } from "../../shared/response-handler";
 import { logger } from "../../shared/logger";
 import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
-import { generateSessionId } from "../../utils/calculation.util";
+import { generateSessionId } from "../../infrastructure/utils/calculation.util";
 
 export interface ChatSession {
   id: string;
@@ -34,13 +35,19 @@ class ChatSessionManager {
   private sessions = new Map<string, ChatSession>();
   private readonly MAX_SESSIONS = 100;
   private readonly SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+  private oldestSessionId: string | null = null;
+  private cleanupScheduled = false;
+  private readonly CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 
   create(config: GroqChatConfig = {}): ChatSession {
-    this.cleanupOldSessions();
+    // Lazy cleanup - only check when needed, not every time
+    if (this.sessions.size >= this.MAX_SESSIONS || !this.cleanupScheduled) {
+      this.scheduleCleanup();
+    }
 
     const session: ChatSession = {
       id: generateSessionId("groq-chat"),
-      model: config.model || "llama-3.3-70b-versatile",
+      model: config.model || DEFAULT_MODELS.TEXT,
       systemInstruction: config.systemInstruction,
       messages: config.history ? [...config.history] : [],
       createdAt: new Date(),
@@ -49,12 +56,16 @@ class ChatSessionManager {
 
     this.sessions.set(session.id, session);
 
-    if (this.sessions.size > this.MAX_SESSIONS) {
-      const sorted = Array.from(this.sessions.entries())
-        .sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
+    // Track oldest session for O(1) removal
+    if (!this.oldestSessionId ||
+        this.sessions.get(this.oldestSessionId)!.createdAt > session.createdAt) {
+      this.oldestSessionId = session.id;
+    }
 
-      const toRemove = sorted.slice(0, this.sessions.size - this.MAX_SESSIONS);
-      toRemove.forEach(([id]) => this.sessions.delete(id));
+    // Fast path: if at limit, just remove oldest
+    if (this.sessions.size > this.MAX_SESSIONS && this.oldestSessionId) {
+      this.sessions.delete(this.oldestSessionId);
+      this.updateOldestSessionId();
     }
 
     return session;
@@ -65,21 +76,53 @@ class ChatSessionManager {
   }
 
   delete(sessionId: string): boolean {
-    return this.sessions.delete(sessionId);
+    const deleted = this.sessions.delete(sessionId);
+    if (deleted && sessionId === this.oldestSessionId) {
+      this.updateOldestSessionId();
+    }
+    return deleted;
+  }
+
+  private scheduleCleanup(): void {
+    if (this.cleanupScheduled) return;
+
+    this.cleanupScheduled = true;
+    // Schedule cleanup for next idle time
+    setTimeout(() => {
+      this.cleanupOldSessions();
+      this.cleanupScheduled = false;
+    }, this.CLEANUP_INTERVAL_MS);
+  }
+
+  private updateOldestSessionId(): void {
+    let oldest: Date | null = null;
+    let oldestId: string | null = null;
+
+    for (const [id, session] of this.sessions.entries()) {
+      if (!oldest || session.createdAt < oldest) {
+        oldest = session.createdAt;
+        oldestId = id;
+      }
+    }
+
+    this.oldestSessionId = oldestId;
   }
 
   private cleanupOldSessions(): void {
     const now = Date.now();
-    const expiredIds: string[] = [];
+    let removed = 0;
 
     for (const [id, session] of this.sessions.entries()) {
       const age = now - session.updatedAt.getTime();
       if (age > this.SESSION_TTL_MS) {
-        expiredIds.push(id);
+        this.sessions.delete(id);
+        removed++;
       }
     }
 
-    expiredIds.forEach((id) => this.sessions.delete(id));
+    if (removed > 0) {
+      this.updateOldestSessionId();
+    }
   }
 
   async send(sessionId: string, content: string): Promise<ChatSendResult> {
@@ -94,6 +137,11 @@ class ChatSessionManager {
     const userMessage: GroqMessage = { role: "user", content };
     session.messages.push(userMessage);
 
+    // Prevent unbounded memory growth
+    if (session.messages.length > 100) {
+      session.messages = session.messages.slice(-50); // Keep last 50
+    }
+
     const messages = this.buildMessages(session);
     const request = RequestBuilder.buildChatRequest(messages, {
       model: session.model,

package/src/application/use-cases/streaming.usecase.ts

@@ -3,10 +3,11 @@
  * Handles streaming text generation
  */
 
-import type { GroqGenerationConfig } from "../../domain/entities";
-import { streamChatCompletion } from "../../infrastructure/http";
+import type { GroqGenerationConfig } from "../../domain/entities/groq.types";
+import { streamChatCompletion } from "../../infrastructure/http/streaming-client";
 import { RequestBuilder } from "../../shared/request-builder";
 import { logger } from "../../shared/logger";
+import { groqHttpClient } from "../../infrastructure/http/groq-http-client";
 
 export interface StreamingCallbacks {
   onChunk?: (chunk: string) => void;
@@ -29,16 +30,21 @@ export async function* streamText(
     promptLength: prompt.length,
   });
 
+  if (!groqHttpClient.isInitialized()) {
+    throw new Error("Groq client not initialized. Call initializeProvider() first.");
+  }
+
+  const config = groqHttpClient.getConfig();
   const request = RequestBuilder.buildPromptRequest(prompt, options);
-  const config = {
-    apiKey: "", // Will be set by factory
-    baseUrl: "", // Will be set by factory
-  };
 
   let fullContent = "";
 
   try {
-    for await (const chunk of streamChatCompletion(request, config)) {
+    for await (const chunk of streamChatCompletion(request, {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      timeoutMs: config.timeoutMs,
+    })) {
       const content = chunk.choices[0]?.delta?.content;
       if (content) {
         fullContent += content;

package/src/application/use-cases/structured-generation.usecase.ts

@@ -1,15 +1,19 @@
 /**
  * Structured Generation Use Case
  * Generates structured JSON output from prompts
+ * Optimized for performance
  */
 
-import type { GroqGenerationConfig, GroqMessage } from "../../domain/entities";
-import { groqHttpClient } from "../../infrastructure/http";
+import type { GroqGenerationConfig } from "../../domain/entities/groq.types";
+import { groqHttpClient } from "../../infrastructure/http/groq-http-client";
 import { RequestBuilder } from "../../shared/request-builder";
+import { Timer } from "../../shared/timer";
+import { logger } from "../../shared/logger";
 import { ResponseHandler } from "../../shared/response-handler";
-import { Timer, logger } from "../../shared/logger";
 import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
-import { cleanJsonResponse } from "../../utils/content-mapper.util";
+import { cleanJsonResponse } from "../../infrastructure/utils/content-mapper.util";
+
+const MAX_CONTENT_LENGTH_FOR_ERROR = 200;
 
 export interface StructuredGenerationOptions<T> {
   model?: string;
@@ -54,6 +58,10 @@ export async function generateStructured<T = Record<string, unknown>>(
   try {
     const parsed = JSON.parse(content) as T;
 
+    if (typeof parsed !== 'object' || parsed === null) {
+      throw new Error("Response is not a valid object");
+    }
+
     logger.debug("StructuredGeneration", "Complete", {
       totalDuration: Timer.format(result.totalMs),
       parsedKeys: Object.keys(parsed),
@@ -66,9 +74,13 @@ export async function generateStructured<T = Record<string, unknown>>(
       contentLength: content.length,
     });
 
+    const truncatedContent = content.length > MAX_CONTENT_LENGTH_FOR_ERROR
+      ? content.substring(0, MAX_CONTENT_LENGTH_FOR_ERROR) + "..."
+      : content;
+
     throw new GroqError(
       GroqErrorType.UNKNOWN_ERROR,
-      `Failed to parse JSON: ${content}`,
+      `Failed to parse JSON response: ${truncatedContent}`,
       error
     );
   }
@@ -80,12 +92,17 @@ function buildSystemPrompt<T>(
 ): string {
   let prompt = "You are a helpful assistant that generates valid JSON output.";
 
-  if (schema) {
-    prompt += `\n\nResponse must conform to this JSON schema:\n${JSON.stringify(schema, null, 2)}`;
-  }
+  if (schema || example) {
+    prompt += "\n\nResponse requirements:";
+
+    if (schema) {
+      // Use compact JSON to reduce tokens and improve speed
+      prompt += `\nSchema: ${JSON.stringify(schema)}`;
+    }
 
-  if (example) {
-    prompt += `\n\nExample response format:\n${JSON.stringify(example, null, 2)}`;
+    if (example) {
+      prompt += `\nExample: ${JSON.stringify(example)}`;
+    }
   }
 
   prompt += "\n\nIMPORTANT: Respond ONLY with valid JSON. No markdown, no code blocks.";

package/src/application/use-cases/text-generation.usecase.ts

@@ -3,11 +3,12 @@
  * Handles simple text generation from prompts
  */
 
-import type { GroqGenerationConfig } from "../../domain/entities";
-import { groqHttpClient } from "../../infrastructure/http";
+import type { GroqGenerationConfig } from "../../domain/entities/groq.types";
+import { groqHttpClient } from "../../infrastructure/http/groq-http-client";
 import { RequestBuilder } from "../../shared/request-builder";
 import { ResponseHandler } from "../../shared/response-handler";
-import { Timer, logger } from "../../shared";
+import { Timer } from "../../shared/timer";
+import { logger } from "../../shared/logger";
 
 export interface TextGenerationOptions {
   model?: string;

package/src/domain/entities/error.types.ts

@@ -22,7 +22,7 @@ export enum GroqErrorType {
   MISSING_CONFIG = "MISSING_CONFIG",
   /** Network error occurred */
   NETWORK_ERROR = "NETWORK_ERROR",
-  /** Request was aborted */
+  /** Request was aborted or timed out */
   ABORT_ERROR = "ABORT_ERROR",
   /** Rate limit exceeded */
   RATE_LIMIT_ERROR = "RATE_LIMIT_ERROR",
@@ -30,6 +30,8 @@ export enum GroqErrorType {
   QUOTA_EXCEEDED = "QUOTA_EXCEEDED",
   /** Server error */
   SERVER_ERROR = "SERVER_ERROR",
+  /** Client error (invalid request) */
+  CLIENT_ERROR = "CLIENT_ERROR",
   /** Unknown error occurred */
   UNKNOWN_ERROR = "UNKNOWN_ERROR",
 }
@@ -38,17 +40,30 @@ export enum GroqErrorType {
  * Map HTTP status codes to error types
  */
 export function mapHttpStatusToErrorType(status: number): GroqErrorType {
+  // Authentication errors
   if (status === 401 || status === 403) {
     return GroqErrorType.INVALID_API_KEY;
   }
+
+  // Rate limiting
   if (status === 429) {
     return GroqErrorType.RATE_LIMIT_ERROR;
   }
+
+  // Quota exceeded
+  if (status === 402) {
+    return GroqErrorType.QUOTA_EXCEEDED;
+  }
+
+  // Server errors
   if (status >= 500 && status < 600) {
     return GroqErrorType.SERVER_ERROR;
   }
+
+  // Client errors (4xx except specific cases above)
   if (status >= 400 && status < 500) {
-    return GroqErrorType.INVALID_API_KEY;
+    return GroqErrorType.CLIENT_ERROR;
   }
+
   return GroqErrorType.UNKNOWN_ERROR;
 }

package/src/index.ts

@@ -2,18 +2,11 @@
  * @umituz/react-native-ai-groq-provider
  * Groq text generation provider for React Native applications
  *
- * DDD Architecture:
- * - Domain: Core entities and types
- * - Application: Use cases and business logic
- * - Infrastructure: External services and HTTP clients
- * - Presentation: React hooks and UI utilities
- * - Shared: Common utilities
- *
  * @author umituz
  * @license MIT
  */
 
-// Domain Layer
+// Domain Layer - Direct exports, no barrel re-exports
 export type {
   GroqConfig,
   GroqGenerationConfig,
@@ -28,12 +21,9 @@ export type {
   GroqChunkChoice,
   GroqErrorResponse,
   GroqChatConfig,
-} from "./domain/entities";
+} from "./domain/entities/groq.types";
 
-export {
-  GROQ_MODELS,
-  DEFAULT_MODELS,
-} from "./domain/entities";
+export { GROQ_MODELS, DEFAULT_MODELS } from "./domain/entities/groq.types";
 
 export {
   GroqError,
@@ -49,59 +39,30 @@ export {
   type ModelInfo,
 } from "./domain/entities/models";
 
-// Application Layer (Use Cases)
-export {
-  generateText,
-  generateStructured,
-  streamText,
-  chatSessionManager,
-  type TextGenerationOptions,
-  type StructuredGenerationOptions,
-  type StreamingCallbacks,
-  type StreamingOptions,
-  type ChatSession,
-  type ChatSendResult,
-} from "./application/use-cases";
+// Application Layer - Direct exports
+export { generateText, type TextGenerationOptions } from "./application/use-cases/text-generation.usecase";
+export { generateStructured, type StructuredGenerationOptions } from "./application/use-cases/structured-generation.usecase";
+export { streamText, type StreamingCallbacks, type StreamingOptions } from "./application/use-cases/streaming.usecase";
+export { chatSessionManager, type ChatSession, type ChatSendResult } from "./application/use-cases/chat-session.usecase";
 
-// Infrastructure Layer
-export {
-  groqHttpClient,
-  streamChatCompletion,
-} from "./infrastructure/http";
+// Infrastructure Layer - Direct exports
+export { groqHttpClient } from "./infrastructure/http/groq-http-client";
+export { streamChatCompletion } from "./infrastructure/http/streaming-client";
 
-// Presentation Layer
-export {
-  useGroq,
-  type UseGroqOptions,
-  type UseGroqReturn,
-} from "./presentation";
+// Presentation Layer - Direct exports
+export { useGroq, type UseGroqOptions, type UseGroqReturn } from "./presentation/hooks/use-groq.hook";
 
-// Shared Layer
-export {
-  logger,
-  LogLevel,
-  Timer,
-  RequestBuilder,
-  ResponseHandler,
-  type LogContext,
-  type TimerResult,
-  type RequestBuilderOptions,
-  type ResponseHandlerResult,
-} from "./shared";
+// Shared Layer - Direct exports
+export { logger, LogLevel, type LogContext } from "./shared/logger";
+export { Timer, type TimerResult } from "./shared/timer";
+export { RequestBuilder, type RequestBuilderOptions } from "./shared/request-builder";
+export { ResponseHandler, type ResponseHandlerResult } from "./shared/response-handler";
 
-// Provider Factory
-export {
-  ConfigBuilder,
-  GenerationConfigBuilder,
-  providerFactory,
-  initializeProvider,
-  configureProvider,
-  resetProvider,
-  type ProviderConfig,
-  type ProviderFactoryOptions,
-} from "./providers/ProviderFactory";
+// Provider Factory - Direct exports, no wrappers
+export { ConfigBuilder, GenerationConfigBuilder } from "./providers/ConfigBuilder";
+export { initializeProvider, resetProvider, isProviderInitialized, type ProviderConfig } from "./providers/ProviderFactory";
 
-// Utilities
+// Utilities - Direct exports, no barrel re-exports
 export {
   createUserMessage,
   createAssistantMessage,
@@ -125,7 +86,7 @@ export {
   executeWithRetry,
   type AsyncStateSetters,
   type AsyncCallbacks,
-} from "./infrastructure/utils/async";
+} from "./infrastructure/utils/async/execute-state.util";
 
 export {
   generateRandomId,
@@ -143,7 +104,4 @@ export {
   calculateAverage,
 } from "./infrastructure/utils/calculation.util";
 
-export {
-  telemetry,
-  useTelemetry,
-} from "./infrastructure/telemetry";
+export { telemetry, useTelemetry } from "./infrastructure/telemetry/TelemetryHooks";

package/src/infrastructure/http/groq-http-client.ts

@@ -7,13 +7,14 @@ import type {
   GroqConfig,
   GroqChatRequest,
   GroqChatResponse,
-  GroqChatChunk,
-} from "../../domain/entities";
+} from "../../domain/entities/groq.types";
 import { GroqError, GroqErrorType, mapHttpStatusToErrorType } from "../../domain/entities/error.types";
 import { logger } from "../../shared/logger";
 
 const DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
 const DEFAULT_TIMEOUT = 60000;
+const MIN_API_KEY_LENGTH = 10;
+const GROQ_KEY_PREFIX = "gsk_";
 
 class GroqHttpClient {
   private config: GroqConfig | null = null;
@@ -28,17 +29,30 @@ class GroqHttpClient {
       baseUrl: config.baseUrl || DEFAULT_BASE_URL,
     });
 
-    if (!apiKey || apiKey.length < 10) {
+    if (!apiKey) {
       throw new GroqError(
         GroqErrorType.INVALID_API_KEY,
-        "API key is required and must be at least 10 characters"
+        "API key is required"
       );
     }
 
+    if (apiKey.length < MIN_API_KEY_LENGTH) {
+      throw new GroqError(
+        GroqErrorType.INVALID_API_KEY,
+        `API key must be at least ${MIN_API_KEY_LENGTH} characters`
+      );
+    }
+
+    if (!apiKey.startsWith(GROQ_KEY_PREFIX)) {
+      logger.warn("GroqClient", "API key does not start with expected prefix", {
+        prefix: GROQ_KEY_PREFIX,
+      });
+    }
+
     this.config = {
       apiKey,
-      baseUrl: config.baseUrl || DEFAULT_BASE_URL,
-      timeoutMs: config.timeoutMs || DEFAULT_TIMEOUT,
+      baseUrl: this.normalizeBaseUrl(config.baseUrl),
+      timeoutMs: this.validateTimeout(config.timeoutMs),
       textModel: config.textModel,
     };
     this.initialized = true;
@@ -48,6 +62,28 @@ class GroqHttpClient {
     });
   }
 
+  private normalizeBaseUrl(baseUrl?: string): string {
+    if (!baseUrl) {
+      return DEFAULT_BASE_URL;
+    }
+    return baseUrl.replace(/\/+$/, ""); // Remove trailing slashes
+  }
+
+  private validateTimeout(timeout?: number): number {
+    const DEFAULT = DEFAULT_TIMEOUT;
+    if (timeout === undefined || timeout === null) {
+      return DEFAULT;
+    }
+    if (!Number.isFinite(timeout) || timeout <= 0) {
+      logger.warn("GroqClient", "Invalid timeout, using default", {
+        provided: timeout,
+        default: DEFAULT,
+      });
+      return DEFAULT;
+    }
+    return Math.min(timeout, 300000); // Cap at 5 minutes
+  }
+
   isInitialized(): boolean {
     return this.initialized && this.config !== null;
   }
@@ -95,7 +131,19 @@ class GroqHttpClient {
         await this.handleErrorResponse(response);
       }
 
-      return (await response.json()) as T;
+      const text = await response.text();
+      if (!text) {
+        throw new GroqError(GroqErrorType.SERVER_ERROR, "Empty response from server");
+      }
+
+      try {
+        return JSON.parse(text) as T;
+      } catch {
+        throw new GroqError(
+          GroqErrorType.SERVER_ERROR,
+          `Invalid JSON response: ${text.substring(0, 200)}`
+        );
+      }
     } catch (error) {
       throw this.handleRequestError(error);
     }
@@ -106,9 +154,17 @@ class GroqHttpClient {
     const errorType = mapHttpStatusToErrorType(response.status);
 
     try {
-      const errorData = (await response.json()) as { error?: { message?: string } };
-      if (errorData.error?.message) {
-        errorMessage = errorData.error.message;
+      const text = await response.text();
+      if (text) {
+        try {
+          const errorData = JSON.parse(text) as { error?: { message?: string } };
+          if (errorData.error?.message) {
+            errorMessage = errorData.error.message;
+          }
+        } catch {
+          // Use text content if JSON parsing fails
+          errorMessage = text.substring(0, 500);
+        }
       }
     } catch {
       // Use default message
@@ -122,9 +178,9 @@ class GroqHttpClient {
 
     if (error instanceof Error) {
       if (error.name === "AbortError") {
-        return new GroqError(GroqErrorType.ABORT_ERROR, "Request aborted", error);
+        return new GroqError(GroqErrorType.ABORT_ERROR, "Request timeout", error);
       }
-      if (error.message.includes("network")) {
+      if (error.name === "TypeError" && error.message.includes("network")) {
         return new GroqError(GroqErrorType.NETWORK_ERROR, "Network error", error);
       }
     }