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

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

@@ -1,125 +1,177 @@
 /**
  * Streaming Client
  * Handles SSE streaming from Groq API
+ * Optimized for performance and memory efficiency
  */
 
-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;
 
 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,
-    });
-
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      await handleErrorResponse(response);
-    }
+  const client = new GroqStreamingClient();
+  yield* client.stream(request, config);
+}
+
+class GroqStreamingClient {
+  private normalizeBaseUrl(baseUrl: string): string {
+    return baseUrl.replace(/\/+$/, "");
+  }
 
-    if (!response.body) {
-      throw new GroqError(GroqErrorType.NETWORK_ERROR, "Response body is null");
+  private validateTimeout(timeout?: number): number {
+    if (timeout === undefined || timeout === null || timeout <= 0) {
+      return DEFAULT_TIMEOUT;
     }
+    return Math.min(timeout, 300000);
+  }
 
-    yield* parseSSE(response.body);
+  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);
+
+    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,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
 
-  } catch (error) {
-    throw handleRequestError(error);
-  }
-}
+      if (!response.body) {
+        throw new GroqError(GroqErrorType.NETWORK_ERROR, "Response body is empty");
+      }
+
+      yield* this.parseSSE(response.body);
 
-async function* parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<GroqChatChunk> {
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const MAX_BUFFER_SIZE = 1024 * 1024;
+    } catch (error) {
+      throw this.handleRequestError(error);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
+  private async* parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<GroqChatChunk> {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const chunks: string[] = []; // Array for efficient string building
+    let buffer = "";
+    let consecutiveErrors = 0;
 
-      buffer += decoder.decode(value, { stream: true });
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
 
-      const safeSize = calculateSafeBufferSize(buffer.length, MAX_BUFFER_SIZE);
-      if (safeSize < buffer.length) {
-        buffer = buffer.slice(-safeSize);
-      }
+        chunks.push(decoder.decode(value, { stream: true }));
 
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
+        // Join all chunks at once - more efficient than +=
+        buffer = chunks.join("");
+        chunks.length = 0; // Clear array
 
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed === "data: [DONE]") continue;
+        // Trim buffer if necessary
+        if (buffer.length > MAX_BUFFER_SIZE) {
+          buffer = buffer.slice(-Math.floor(MAX_BUFFER_SIZE / 2));
+          logger.warn("StreamingClient", "Buffer trimmed");
+        }
 
-        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 });
+        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: ")) {
+            try {
+              const jsonStr = trimmed.slice(6);
+              const chunk = JSON.parse(jsonStr) as GroqChatChunk;
+              consecutiveErrors = 0;
+              yield chunk;
+            } catch (error) {
+              consecutiveErrors++;
+              logger.error("StreamingClient", "Parse error", {
+                error: error instanceof Error ? error.message : String(error),
+                consecutiveErrors,
+              });
+
+              if (consecutiveErrors >= MAX_INCOMPLETE_CHUNKS) {
+                throw new GroqError(
+                  GroqErrorType.SERVER_ERROR,
+                  `Stream corrupted: ${consecutiveErrors} 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);
-}
+  private handleRequestError(error: unknown): GroqError {
+    if (error instanceof GroqError) return error;
 
-function 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

@@ -1,6 +1,7 @@
 /**
  * Telemetry Hooks
  * Simple telemetry tracking for Groq operations
+ * Optimized with O(1) circular buffer
  */
 
 import { useMemo } from "react";
@@ -13,11 +14,17 @@ 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 head = 0; // Write position
+  private count = 0; // Actual number of events
+
+  constructor() {
+    this.enabled = typeof __DEV__ !== "undefined" && __DEV__;
+  }
 
   /**
-   * Log a telemetry event
+   * Log a telemetry event - O(1) operation
    */
   log(name: string, data?: Record<string, unknown>): void {
     if (!this.enabled) return;
@@ -28,30 +35,44 @@ class Telemetry {
       data,
     };
 
-    this.events.push(event);
+    // Circular buffer: O(1) write
+    this.events[this.head] = event;
+    this.head = (this.head + 1) % this.MAX_EVENTS;
 
-    // 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);
-    }
-
-    if (__DEV__) {
-      console.log(`[Groq Telemetry] ${name}`, data);
+    if (this.count < this.MAX_EVENTS) {
+      this.count++;
     }
   }
 
   /**
-   * Get all events (returns readonly reference for performance)
+   * Get all events in chronological order
+   * Returns frozen array to prevent external mutations
    */
   getEvents(): ReadonlyArray<TelemetryEvent> {
-    return this.events;
+    if (this.count === 0) {
+      return Object.freeze([]);
+    }
+
+    // O(n) but only when called, not on every log
+    if (this.count < this.MAX_EVENTS) {
+      // Not wrapped yet, just return slice
+      return Object.freeze(this.events.slice(0, this.count));
+    }
+
+    // Wrapped around - need to reorder
+    const result: TelemetryEvent[] = new Array(this.count);
+    for (let i = 0; i < this.count; i++) {
+      result[i] = this.events[(this.head + i) % this.MAX_EVENTS];
+    }
+    return Object.freeze(result);
   }
 
   /**
-   * Clear all events
+   * Clear all events - O(1)
    */
   clear(): void {
-    this.events.length = 0; // More efficient than reassignment
+    this.head = 0;
+    this.count = 0;
   }
 
   /**
@@ -59,7 +80,6 @@ class Telemetry {
    */
   setEnabled(enabled: boolean): void {
     this.enabled = enabled;
-    // Disable cleanup when disabled
     if (!enabled) {
       this.clear();
     }
@@ -73,10 +93,10 @@ class Telemetry {
   }
 
   /**
-   * Get event count (lightweight check)
+   * Get event count - O(1)
    */
   getEventCount(): number {
-    return this.events.length;
+    return this.count;
   }
 }
 
@@ -87,7 +107,7 @@ export const telemetry = new Telemetry();
 
 /**
  * Hook to use telemetry in components
- * Optimized with useMemo to prevent unnecessary re-renders
+ * Memoized to prevent unnecessary re-renders
  */
 export function useTelemetry() {
   return useMemo(

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

@@ -1,21 +1,23 @@
 /**
  * Calculation Utilities
  * Common calculation and utility functions for numeric operations
+ * Optimized for performance
  */
 
+const MAX_RANDOM_ID_LENGTH = 11;
+
 /**
  * Generate a random unique identifier string
- * @param length - Length of the random string (default: 9)
- * @returns Random string in base-36
+ * Uses optimized single-pass operations
  */
 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, 2 + safeLength);
+  return randomStr;
 }
 
 /**
  * Generate a unique chat session ID
- * @param prefix - Optional prefix for the ID (default: "groq-chat")
- * @returns Unique session identifier
  */
 export function generateSessionId(prefix: string = "groq-chat"): string {
   return `${prefix}-${Date.now()}-${generateRandomId(9)}`;
@@ -23,16 +25,13 @@ export function generateSessionId(prefix: string = "groq-chat"): string {
 
 /**
  * Calculate maximum number of messages based on token limit
- * Uses a heuristic of approximately 100 tokens per message
- * @param maxTokens - Maximum allowed tokens
- * @param tokensPerMessage - Estimated tokens per message (default: 100)
- * @returns Maximum number of messages
  */
 export function calculateMaxMessages(
   maxTokens: number,
   tokensPerMessage: number = 100
 ): number {
-  if (maxTokens <= 0) {
+  if (!Number.isFinite(maxTokens) || maxTokens <= 0 ||
+      !Number.isFinite(tokensPerMessage) || tokensPerMessage <= 0) {
     return 0;
   }
   return Math.floor(maxTokens / tokensPerMessage);
@@ -40,12 +39,10 @@ export function calculateMaxMessages(
 
 /**
  * Calculate exponential backoff delay
- * @param baseDelay - Initial delay in milliseconds
- * @param attempt - Current attempt number (0-indexed)
- * @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);
@@ -53,41 +50,37 @@ export function calculateExponentialBackoff(baseDelay: number, attempt: number):
 
 /**
  * Clamp a value between min and max
- * @param value - Value to clamp
- * @param min - Minimum allowed value
- * @param max - Maximum allowed value
- * @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);
 }
 
 /**
  * Calculate percentage with optional decimal places
- * @param value - Current value
- * @param total - Total value
- * @param decimals - Number of decimal places (default: 2)
- * @returns Percentage value
+ * Optimized: avoids string conversion
  */
 export function calculatePercentage(
   value: number,
   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 multiplier = Math.pow(10, Math.max(0, Math.min(20, Math.floor(decimals))));
+  return Math.round((value / total) * 100 * multiplier) / multiplier;
 }
 
 /**
  * Calculate buffer size limit for streaming
- * Ensures buffer doesn't grow beyond reasonable limits
- * @param currentSize - Current buffer size
- * @param maxSize - Maximum allowed buffer size
- * @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);
   }
@@ -96,86 +89,89 @@ export function calculateSafeBufferSize(currentSize: number, maxSize: number): n
 
 /**
  * Calculate token estimate from text
- * Rough approximation: ~4 characters per token
- * @param text - Text to estimate tokens for
- * @returns Estimated token count
  */
 export function estimateTokens(text: string): number {
-  if (!text) {
-    return 0;
-  }
+  if (!text) return 0;
   return Math.ceil(text.length / 4);
 }
 
 /**
  * Calculate if message count is within safe limits
- * @param messageCount - Current message count
- * @param maxMessages - Maximum allowed messages
- * @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;
 }
 
 /**
  * Calculate retry delay with jitter
- * Adds random jitter to prevent thundering herd
- * @param baseDelay - Base delay in milliseconds
- * @param attempt - Current attempt number
- * @param jitterFactor - Jitter factor (0-1, default: 0.1)
- * @returns Delay with jitter applied
  */
 export function calculateRetryDelayWithJitter(
   baseDelay: number,
   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);
 }
 
 /**
  * Calculate timeout for network requests
- * Based on exponential backoff with a maximum cap
- * @param attempt - Current attempt number
- * @param baseTimeout - Base timeout in milliseconds (default: 5000)
- * @param maxTimeout - Maximum timeout in milliseconds (default: 30000)
- * @returns Timeout in milliseconds
  */
 export function calculateRequestTimeout(
   attempt: number,
   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);
 }
 
 /**
  * Calculate data transfer rate
- * @param bytes - Number of bytes transferred
- * @param milliseconds - Time taken in milliseconds
- * @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;
-  const kilobytes = bytes / 1024;
-  return Number((kilobytes / seconds).toFixed(2));
+  const kilobytesPerSecond = (bytes / 1024) * (1000 / milliseconds);
+  return Math.round(kilobytesPerSecond * 100) / 100;
 }
 
 /**
  * Calculate average from array of numbers
- * @param values - Array of numbers
- * @returns Average value or 0 if array is empty
+ * Optimized: Single pass with inline validation
  */
 export function calculateAverage(values: number[]): number {
-  if (values.length === 0) {
+  if (!Array.isArray(values) || values.length === 0) {
     return 0;
   }
-  const sum = values.reduce((acc, val) => acc + val, 0);
-  return sum / values.length;
+
+  let sum = 0;
+  let count = 0;
+
+  // Single pass: validate and sum
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    if (Number.isFinite(v)) {
+      sum += v;
+      count++;
+    }
+  }
+
+  return count === 0 ? 0 : sum / count;
 }

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