@umituz/react-native-ai-groq-provider 1.0.23 → 1.0.25

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

@@ -3,123 +3,174 @@
  * Handles SSE streaming from Groq API
  */
 
-import type { GroqChatRequest, GroqChatChunk } from "../../domain/entities";
+import type { GroqChatRequest, GroqChatChunk } from "../../domain/entities/groq.types";
 import { GroqError, GroqErrorType, mapHttpStatusToErrorType } from "../../domain/entities/error.types";
 import { logger } from "../../shared/logger";
-import { calculateSafeBufferSize } from "../../utils/calculation.util";
 
 const DEFAULT_TIMEOUT = 60000;
+const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB
+const MAX_INCOMPLETE_CHUNKS = 10; // Max consecutive parse failures
 
 export async function* streamChatCompletion(
   request: GroqChatRequest,
   config: { apiKey: string; baseUrl: string; timeoutMs?: number }
 ): AsyncGenerator<GroqChatChunk> {
-  const url = `${config.baseUrl}/chat/completions`;
-  const timeout = config.timeoutMs || DEFAULT_TIMEOUT;
-
-  logger.debug("StreamingClient", "Starting stream", {
-    model: request.model,
-  });
-
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-  try {
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${config.apiKey}`,
-      },
-      body: JSON.stringify({ ...request, stream: true }),
-      signal: controller.signal,
-    });
+  const client = new GroqStreamingClient();
+  yield* client.stream(request, config);
+}
 
-    clearTimeout(timeoutId);
+class GroqStreamingClient {
+  private normalizeBaseUrl(baseUrl: string): string {
+    return baseUrl.replace(/\/+$/, ""); // Remove trailing slashes
+  }
 
-    if (!response.ok) {
-      await handleErrorResponse(response);
+  private validateTimeout(timeout?: number): number {
+    if (timeout === undefined || timeout === null || timeout <= 0) {
+      return DEFAULT_TIMEOUT;
     }
+    return Math.min(timeout, 300000); // Cap at 5 minutes
+  }
 
-    if (!response.body) {
-      throw new GroqError(GroqErrorType.NETWORK_ERROR, "Response body is null");
-    }
+  async* stream(
+    request: GroqChatRequest,
+    config: { apiKey: string; baseUrl: string; timeoutMs?: number }
+  ): AsyncGenerator<GroqChatChunk> {
+    const baseUrl = this.normalizeBaseUrl(config.baseUrl);
+    const url = `${baseUrl}/chat/completions`;
+    const timeout = this.validateTimeout(config.timeoutMs);
 
-    yield* parseSSE(response.body);
+    logger.debug("StreamingClient", "Starting stream", {
+      model: request.model,
+    });
 
-  } catch (error) {
-    throw handleRequestError(error);
-  }
-}
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
 
-async function* parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<GroqChatChunk> {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const MAX_BUFFER_SIZE = 1024 * 1024;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${config.apiKey}`,
+        },
+        body: JSON.stringify({ ...request, stream: true }),
+        signal: controller.signal,
+      });
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
+      clearTimeout(timeoutId);
 
-      buffer += decoder.decode(value, { stream: true });
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
 
-      const safeSize = calculateSafeBufferSize(buffer.length, MAX_BUFFER_SIZE);
-      if (safeSize < buffer.length) {
-        buffer = buffer.slice(-safeSize);
+      if (!response.body) {
+        throw new GroqError(GroqErrorType.NETWORK_ERROR, "Response body is empty");
       }
 
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
+      yield* this.parseSSE(response.body);
+
+    } catch (error) {
+      throw this.handleRequestError(error);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  private async* parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<GroqChatChunk> {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let consecutiveErrors = 0;
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
 
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed === "data: [DONE]") continue;
+        buffer += decoder.decode(value, { stream: true });
 
-        if (trimmed.startsWith("data: ")) {
-          try {
-            const chunk = JSON.parse(trimmed.slice(6)) as GroqChatChunk;
-            yield chunk;
-          } catch (error) {
-            logger.error("StreamingClient", "Failed to parse SSE chunk", { error });
+        // Safe buffer management - only trim if necessary
+        if (buffer.length > MAX_BUFFER_SIZE) {
+          const keepSize = Math.floor(MAX_BUFFER_SIZE / 2);
+          buffer = buffer.slice(-keepSize);
+          logger.warn("StreamingClient", "Buffer trimmed due to size limit");
+        }
+
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed === "data: [DONE]") continue;
+
+          if (trimmed.startsWith("data: ")) {
+            try {
+              const jsonStr = trimmed.slice(6);
+              const chunk = JSON.parse(jsonStr) as GroqChatChunk;
+              consecutiveErrors = 0; // Reset error counter on success
+              yield chunk;
+            } catch (error) {
+              consecutiveErrors++;
+              logger.error("StreamingClient", "Failed to parse SSE chunk", {
+                error,
+                chunk: trimmed.substring(0, 100),
+                consecutiveErrors,
+              });
+
+              // After too many consecutive errors, abort the stream
+              if (consecutiveErrors >= MAX_INCOMPLETE_CHUNKS) {
+                throw new GroqError(
+                  GroqErrorType.SERVER_ERROR,
+                  `Stream corrupted: ${consecutiveErrors} consecutive parse failures`
+                );
+              }
+            }
           }
         }
       }
+    } finally {
+      reader.releaseLock();
     }
-  } finally {
-    reader.releaseLock();
   }
-}
 
-async function handleErrorResponse(response: Response): Promise<never> {
-  let errorMessage = `HTTP ${response.status}`;
-  const errorType = mapHttpStatusToErrorType(response.status);
+  private async handleErrorResponse(response: Response): Promise<never> {
+    let errorMessage = `HTTP ${response.status}`;
+    const errorType = mapHttpStatusToErrorType(response.status);
+
+    try {
+      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 {
+          errorMessage = text.substring(0, 500);
+        }
+      }
+    } catch {
+      // Use default message
+    }
 
-  try {
-    const errorData = (await response.json()) as { error?: { message?: string } };
-    if (errorData.error?.message) errorMessage = errorData.error.message;
-  } catch {
-    // Use default
+    throw new GroqError(errorType, errorMessage);
   }
 
-  throw new GroqError(errorType, errorMessage);
-}
-
-function handleRequestError(error: unknown): GroqError {
-  if (error instanceof GroqError) return error;
+  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 aborted", error);
-    }
-    if (error.message.includes("network")) {
-      return new GroqError(GroqErrorType.NETWORK_ERROR, "Network error", error);
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new GroqError(GroqErrorType.ABORT_ERROR, "Request timeout", error);
+      }
+      if (error.name === "TypeError" && error.message.includes("fetch")) {
+        return new GroqError(GroqErrorType.NETWORK_ERROR, "Network error", error);
+      }
     }
-  }
 
-  return new GroqError(
-    GroqErrorType.UNKNOWN_ERROR,
-    error instanceof Error ? error.message : "Unknown error"
-  );
+    return new GroqError(
+      GroqErrorType.UNKNOWN_ERROR,
+      error instanceof Error ? error.message : "Unknown error"
+    );
+  }
 }

package/src/infrastructure/telemetry/TelemetryHooks.ts

@@ -3,7 +3,7 @@
  * Simple telemetry tracking for Groq operations
  */
 
-import { useMemo } from "react";
+import { useMemo, useRef } from "react";
 
 type TelemetryEvent = {
   name: string;
@@ -13,8 +13,14 @@ type TelemetryEvent = {
 
 class Telemetry {
   private events: TelemetryEvent[] = [];
-  private enabled = __DEV__;
-  private readonly MAX_EVENTS = 1000; // Prevent unlimited memory growth
+  private enabled: boolean;
+  private readonly MAX_EVENTS = 1000;
+  private nextIndex = 0; // For circular buffer
+  private isCircular = false; // Track when we've wrapped around
+
+  constructor() {
+    this.enabled = typeof __DEV__ !== "undefined" && __DEV__;
+  }
 
   /**
    * Log a telemetry event
@@ -28,11 +34,14 @@ class Telemetry {
       data,
     };
 
-    this.events.push(event);
-
-    // Auto-cleanup old events to prevent memory leak
-    if (this.events.length > this.MAX_EVENTS) {
-      this.events.splice(0, this.events.length - this.MAX_EVENTS);
+    // Use circular buffer pattern for O(1) insertion
+    if (this.events.length < this.MAX_EVENTS) {
+      this.events.push(event);
+    } else {
+      // Circular buffer: overwrite oldest event
+      this.events[this.nextIndex] = event;
+      this.nextIndex = (this.nextIndex + 1) % this.MAX_EVENTS;
+      this.isCircular = true;
     }
 
     if (__DEV__) {
@@ -41,17 +50,27 @@ class Telemetry {
   }
 
   /**
-   * Get all events (returns readonly reference for performance)
+   * Get all events
    */
   getEvents(): ReadonlyArray<TelemetryEvent> {
-    return this.events;
+    if (this.isCircular) {
+      // Return events in circular order (oldest first)
+      const result = [
+        ...this.events.slice(this.nextIndex),
+        ...this.events.slice(0, this.nextIndex),
+      ];
+      return Object.freeze(result);
+    }
+    return Object.freeze(this.events);
   }
 
   /**
    * Clear all events
    */
   clear(): void {
-    this.events.length = 0; // More efficient than reassignment
+    this.events.length = 0;
+    this.nextIndex = 0;
+    this.isCircular = false;
   }
 
   /**
@@ -59,7 +78,6 @@ class Telemetry {
    */
   setEnabled(enabled: boolean): void {
     this.enabled = enabled;
-    // Disable cleanup when disabled
     if (!enabled) {
       this.clear();
     }
@@ -76,7 +94,7 @@ class Telemetry {
    * Get event count (lightweight check)
    */
   getEventCount(): number {
-    return this.events.length;
+    return this.isCircular ? this.MAX_EVENTS : this.events.length;
   }
 }
 
@@ -90,14 +108,13 @@ export const telemetry = new Telemetry();
  * Optimized with useMemo to prevent unnecessary re-renders
  */
 export function useTelemetry() {
-  return useMemo(
-    () => ({
-      log: telemetry.log.bind(telemetry),
-      getEvents: telemetry.getEvents.bind(telemetry),
-      clear: telemetry.clear.bind(telemetry),
-      isEnabled: telemetry.isEnabled.bind(telemetry),
-      getEventCount: telemetry.getEventCount.bind(telemetry),
-    }),
-    []
-  );
+  const methodsRef = useRef({
+    log: telemetry.log.bind(telemetry),
+    getEvents: telemetry.getEvents.bind(telemetry),
+    clear: telemetry.clear.bind(telemetry),
+    isEnabled: telemetry.isEnabled.bind(telemetry),
+    getEventCount: telemetry.getEventCount.bind(telemetry),
+  });
+
+  return useMemo(() => methodsRef.current, []);
 }

package/src/infrastructure/utils/calculation.util.ts

@@ -3,13 +3,17 @@
  * Common calculation and utility functions for numeric operations
  */
 
+const MAX_RANDOM_ID_LENGTH = 11; // Max chars from Math.random().toString(36)
+
 /**
  * Generate a random unique identifier string
- * @param length - Length of the random string (default: 9)
+ * @param length - Length of the random string (default: 9, max: 11)
  * @returns Random string in base-36
  */
 export function generateRandomId(length: number = 9): string {
-  return Math.random().toString(36).substring(2, 2 + length);
+  const safeLength = Math.min(Math.max(1, Math.floor(length)), MAX_RANDOM_ID_LENGTH);
+  const randomStr = Math.random().toString(36).substring(2);
+  return randomStr.substring(0, safeLength);
 }
 
 /**
@@ -32,7 +36,10 @@ export function calculateMaxMessages(
   maxTokens: number,
   tokensPerMessage: number = 100
 ): number {
-  if (maxTokens <= 0) {
+  if (!Number.isFinite(maxTokens) || maxTokens <= 0) {
+    return 0;
+  }
+  if (!Number.isFinite(tokensPerMessage) || tokensPerMessage <= 0) {
     return 0;
   }
   return Math.floor(maxTokens / tokensPerMessage);
@@ -45,7 +52,7 @@ export function calculateMaxMessages(
  * @returns Delay in milliseconds
  */
 export function calculateExponentialBackoff(baseDelay: number, attempt: number): number {
-  if (baseDelay < 0 || attempt < 0) {
+  if (!Number.isFinite(baseDelay) || baseDelay < 0 || !Number.isFinite(attempt) || attempt < 0) {
     return 0;
   }
   return baseDelay * Math.pow(2, attempt);
@@ -59,6 +66,9 @@ export function calculateExponentialBackoff(baseDelay: number, attempt: number):
  * @returns Clamped value
  */
 export function clamp(value: number, min: number, max: number): number {
+  if (!Number.isFinite(value)) return min;
+  if (!Number.isFinite(min)) return max;
+  if (!Number.isFinite(max)) return value;
   return Math.min(Math.max(value, min), max);
 }
 
@@ -74,10 +84,11 @@ export function calculatePercentage(
   total: number,
   decimals: number = 2
 ): number {
-  if (total === 0) {
+  if (!Number.isFinite(value) || !Number.isFinite(total) || total === 0) {
     return 0;
   }
-  return Number(((value / total) * 100).toFixed(decimals));
+  const safeDecimals = Math.max(0, Math.min(20, Math.floor(decimals)));
+  return Number(((value / total) * 100).toFixed(safeDecimals));
 }
 
 /**
@@ -88,6 +99,9 @@ export function calculatePercentage(
  * @returns Safe buffer size
  */
 export function calculateSafeBufferSize(currentSize: number, maxSize: number): number {
+  if (!Number.isFinite(currentSize) || !Number.isFinite(maxSize) || maxSize <= 0) {
+    return 0;
+  }
   if (currentSize > maxSize) {
     return Math.floor(maxSize / 2);
   }
@@ -114,7 +128,10 @@ export function estimateTokens(text: string): number {
  * @returns Whether within safe limits
  */
 export function isWithinSafeLimit(messageCount: number, maxMessages: number): boolean {
-  return messageCount >= 0 && messageCount <= maxMessages;
+  return Number.isFinite(messageCount) &&
+         Number.isFinite(maxMessages) &&
+         messageCount >= 0 &&
+         messageCount <= maxMessages;
 }
 
 /**
@@ -130,8 +147,13 @@ export function calculateRetryDelayWithJitter(
   attempt: number,
   jitterFactor: number = 0.1
 ): number {
+  if (!Number.isFinite(baseDelay) || baseDelay < 0 ||
+      !Number.isFinite(attempt) || attempt < 0) {
+    return 0;
+  }
+  const safeJitterFactor = clamp(jitterFactor, 0, 1);
   const exponentialDelay = calculateExponentialBackoff(baseDelay, attempt);
-  const jitter = exponentialDelay * jitterFactor * (Math.random() * 2 - 1);
+  const jitter = exponentialDelay * safeJitterFactor * (Math.random() * 2 - 1);
   return Math.max(0, exponentialDelay + jitter);
 }
 
@@ -148,8 +170,13 @@ export function calculateRequestTimeout(
   baseTimeout: number = 5000,
   maxTimeout: number = 30000
 ): number {
-  const timeout = calculateExponentialBackoff(baseTimeout, attempt);
-  return Math.min(timeout, maxTimeout);
+  if (!Number.isFinite(attempt) || attempt < 0) {
+    return baseTimeout;
+  }
+  const safeBaseTimeout = Math.max(0, baseTimeout);
+  const safeMaxTimeout = Math.max(safeBaseTimeout, maxTimeout);
+  const timeout = calculateExponentialBackoff(safeBaseTimeout, attempt);
+  return Math.min(timeout, safeMaxTimeout);
 }
 
 /**
@@ -159,7 +186,8 @@ export function calculateRequestTimeout(
  * @returns Transfer rate in KB/s
  */
 export function calculateTransferRate(bytes: number, milliseconds: number): number {
-  if (milliseconds === 0) {
+  if (!Number.isFinite(bytes) || bytes < 0 ||
+      !Number.isFinite(milliseconds) || milliseconds <= 0) {
     return 0;
   }
   const seconds = milliseconds / 1000;
@@ -173,9 +201,13 @@ export function calculateTransferRate(bytes: number, milliseconds: number): numb
  * @returns Average value or 0 if array is empty
  */
 export function calculateAverage(values: number[]): number {
-  if (values.length === 0) {
+  if (!Array.isArray(values) || values.length === 0) {
+    return 0;
+  }
+  const validValues = values.filter(v => Number.isFinite(v));
+  if (validValues.length === 0) {
     return 0;
   }
-  const sum = values.reduce((acc, val) => acc + val, 0);
-  return sum / values.length;
+  const sum = validValues.reduce((acc, val) => acc + val, 0);
+  return sum / validValues.length;
 }

package/src/infrastructure/utils/content-mapper.util.ts

@@ -3,7 +3,7 @@
  * Utilities for working with message content
  */
 
-import type { GroqMessage } from "../../domain/entities";
+import type { GroqMessage } from "../../domain/entities/groq.types";
 
 /**
  * Create a user message

package/src/presentation/hooks/use-groq.hook.ts

@@ -4,9 +4,11 @@
  */
 
 import { useState, useCallback, useMemo } from "react";
-import type { GroqGenerationConfig } from "../../domain/entities";
-import { generateText, generateStructured, streamText } from "../../application/use-cases";
-import { getUserFriendlyError } from "../../utils/error-mapper.util";
+import type { GroqGenerationConfig } from "../../domain/entities/groq.types";
+import { generateText } from "../../application/use-cases/text-generation.usecase";
+import { generateStructured } from "../../application/use-cases/structured-generation.usecase";
+import { streamText } from "../../application/use-cases/streaming.usecase";
+import { getUserFriendlyError } from "../../infrastructure/utils/error-mapper.util";
 
 export interface UseGroqOptions {
   model?: string;
@@ -39,24 +41,14 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
   const [error, setError] = useState<string | null>(null);
   const [result, setResult] = useState<string | null>(null);
 
-  const stableOptions = useMemo(
-    () => ({
-      model: options.model,
-      generationConfig: options.generationConfig,
-      onStart: options.onStart,
-      onSuccess: options.onSuccess,
-      onError: options.onError,
-    }),
-    [
-      options.model,
-      options.generationConfig?.temperature,
-      options.generationConfig?.maxTokens,
-      options.generationConfig?.topP,
-      options.onStart,
-      options.onSuccess,
-      options.onError,
-    ]
-  );
+  // Memoize options with proper deep equality check
+  const stableOptions = useMemo(() => options, [
+    options.model,
+    JSON.stringify(options.generationConfig),
+    options.onStart,
+    options.onSuccess,
+    options.onError,
+  ]);
 
   const generate = useCallback(
     async (prompt: string, config?: GroqGenerationConfig): Promise<string> => {
@@ -144,7 +136,7 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
             onChunk(c);
           }},
         })) {
-          // Consume iterator
+          fullContent += chunk; // Accumulate all chunks
         }
 
         setResult(fullContent);