@umituz/react-native-ai-groq-provider 1.0.13 → 1.0.15

package/package.json

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

package/src/index.ts

@@ -107,6 +107,22 @@ export {
   type AsyncCallbacks,
 } from "./infrastructure/utils/async";
 
+export {
+  generateRandomId,
+  generateSessionId,
+  calculateMaxMessages,
+  calculateExponentialBackoff,
+  clamp,
+  calculatePercentage,
+  calculateSafeBufferSize,
+  estimateTokens,
+  isWithinSafeLimit,
+  calculateRetryDelayWithJitter,
+  calculateRequestTimeout,
+  calculateTransferRate,
+  calculateAverage,
+} from "./infrastructure/utils/calculation.util";
+
 export {
   telemetry,
   useTelemetry,

package/src/infrastructure/services/ChatSession.ts

@@ -11,6 +11,7 @@ import type {
 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
@@ -59,7 +60,7 @@ export type ChatHistoryMessage = {
  */
 export function createChatSession(config: GroqChatConfig = {}): ChatSession {
   return {
-    id: `groq-chat-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    id: generateSessionId("groq-chat"),
     model: config.model || DEFAULT_MODELS.TEXT,
     systemInstruction: config.systemInstruction,
     messages: config.history ? [...config.history] : [],
@@ -74,13 +75,31 @@ export function createChatSession(config: GroqChatConfig = {}): ChatSession {
  */
 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;
   }
 
@@ -98,6 +117,39 @@ class ChatSessionService {
     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
    */
@@ -247,9 +299,8 @@ export function trimChatHistory(
   messages: GroqMessage[],
   maxTokens: number = 4000
 ): GroqMessage[] {
-  // Simple heuristic: assume average of 4 tokens per message
-  // For production, use a proper token counter
-  const maxMessages = Math.floor(maxTokens / 100);
+  // Calculate max messages using utility function
+  const maxMessages = calculateMaxMessages(maxTokens);
 
   if (messages.length <= maxMessages) {
     return messages;

package/src/infrastructure/services/GroqClient.ts

@@ -10,6 +10,7 @@ import type {
   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
@@ -295,6 +296,7 @@ class GroqHttpClient {
       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();
@@ -302,6 +304,13 @@ class GroqHttpClient {
         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() || "";
 
@@ -315,7 +324,9 @@ class GroqHttpClient {
               const chunk = JSON.parse(jsonStr) as GroqChatChunk;
               yield chunk;
             } catch (error) {
-              console.error("Failed to parse SSE chunk:", error);
+              if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.error("Failed to parse SSE chunk:", error);
+              }
             }
           }
         }

package/src/infrastructure/services/Streaming.ts

@@ -50,15 +50,18 @@ export async function* streaming(
     top_p: options.generationConfig?.topP,
   };
 
+  let fullContent = "";
+
   try {
     for await (const chunk of groqHttpClient.chatCompletionStream(request)) {
       const content = chunk.choices[0]?.delta?.content;
       if (content) {
+        fullContent += content;
         options.callbacks?.onChunk?.(content);
         yield content;
       }
     }
-    options.callbacks?.onComplete?.(await collectStreamContent(request));
+    options.callbacks?.onComplete?.(fullContent);
   } catch (error) {
     options.callbacks?.onError?.(error as Error);
     throw error;
@@ -82,33 +85,20 @@ export async function* streamingChat(
     top_p: options.generationConfig?.topP,
   };
 
+  let fullContent = "";
+
   try {
     for await (const chunk of groqHttpClient.chatCompletionStream(request)) {
       const content = chunk.choices[0]?.delta?.content;
       if (content) {
+        fullContent += content;
         options.callbacks?.onChunk?.(content);
         yield content;
       }
     }
-    options.callbacks?.onComplete?.(await collectStreamContent(request));
+    options.callbacks?.onComplete?.(fullContent);
   } catch (error) {
     options.callbacks?.onError?.(error as Error);
     throw error;
   }
 }
-
-/**
- * Collect full content from streaming (for onComplete callback)
- */
-async function collectStreamContent(request: GroqChatRequest): Promise<string> {
-  let fullContent = "";
-
-  for await (const chunk of groqHttpClient.chatCompletionStream(request)) {
-    const content = chunk.choices[0]?.delta?.content;
-    if (content) {
-      fullContent += content;
-    }
-  }
-
-  return fullContent;
-}

package/src/infrastructure/services/StructuredText.ts

@@ -11,6 +11,7 @@ import type {
 import { groqHttpClient } from "./GroqClient";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
+import { cleanJsonResponse } from "../../infrastructure/utils/content-mapper.util";
 
 export interface StructuredTextOptions<T> {
   model?: string;
@@ -111,17 +112,7 @@ export async function structuredText<T = Record<string, unknown>>(
     });
   }
 
-  // Clean up the response: remove markdown code blocks if present
-  content = content.trim();
-  if (content.startsWith("```json")) {
-    content = content.slice(7);
-  } else if (content.startsWith("```")) {
-    content = content.slice(3);
-  }
-  if (content.endsWith("```")) {
-    content = content.slice(0, -3);
-  }
-  content = content.trim();
+  content = cleanJsonResponse(content);
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[Groq] Attempting JSON parse...");
@@ -232,17 +223,7 @@ export async function structuredChat<T = Record<string, unknown>>(
     );
   }
 
-  // Clean up the response: remove markdown code blocks if present
-  content = content.trim();
-  if (content.startsWith("```json")) {
-    content = content.slice(7);
-  } else if (content.startsWith("```")) {
-    content = content.slice(3);
-  }
-  if (content.endsWith("```")) {
-    content = content.slice(0, -3);
-  }
-  content = content.trim();
+  content = cleanJsonResponse(content);
 
   const totalDuration = Date.now() - startTime;
   if (typeof __DEV__ !== "undefined" && __DEV__) {

package/src/infrastructure/telemetry/TelemetryHooks.ts

@@ -3,6 +3,8 @@
  * Simple telemetry tracking for Groq operations
  */
 
+import { useMemo } from "react";
+
 type TelemetryEvent = {
   name: string;
   timestamp: number;
@@ -12,6 +14,7 @@ type TelemetryEvent = {
 class Telemetry {
   private events: TelemetryEvent[] = [];
   private enabled = __DEV__;
+  private readonly MAX_EVENTS = 1000; // Prevent unlimited memory growth
 
   /**
    * Log a telemetry event
@@ -27,23 +30,28 @@ class Telemetry {
 
     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);
+    }
+
     if (__DEV__) {
       console.log(`[Groq Telemetry] ${name}`, data);
     }
   }
 
   /**
-   * Get all events
+   * Get all events (returns readonly reference for performance)
    */
-  getEvents(): TelemetryEvent[] {
-    return [...this.events];
+  getEvents(): ReadonlyArray<TelemetryEvent> {
+    return this.events;
   }
 
   /**
    * Clear all events
    */
   clear(): void {
-    this.events = [];
+    this.events.length = 0; // More efficient than reassignment
   }
 
   /**
@@ -51,6 +59,10 @@ class Telemetry {
    */
   setEnabled(enabled: boolean): void {
     this.enabled = enabled;
+    // Disable cleanup when disabled
+    if (!enabled) {
+      this.clear();
+    }
   }
 
   /**
@@ -59,6 +71,13 @@ class Telemetry {
   isEnabled(): boolean {
     return this.enabled;
   }
+
+  /**
+   * Get event count (lightweight check)
+   */
+  getEventCount(): number {
+    return this.events.length;
+  }
 }
 
 /**
@@ -68,12 +87,17 @@ export const telemetry = new Telemetry();
 
 /**
  * Hook to use telemetry in components
+ * Optimized with useMemo to prevent unnecessary re-renders
  */
 export function useTelemetry() {
-  return {
-    log: telemetry.log.bind(telemetry),
-    getEvents: telemetry.getEvents.bind(telemetry),
-    clear: telemetry.clear.bind(telemetry),
-    isEnabled: telemetry.isEnabled.bind(telemetry),
-  };
+  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),
+    }),
+    []
+  );
 }

package/src/infrastructure/utils/async/execute-state.util.ts

@@ -2,6 +2,11 @@
  * Async State Utilities
  */
 
+import {
+  calculateExponentialBackoff,
+  clamp,
+} from "../calculation.util";
+
 /**
  * State setters for async operations
  */
@@ -50,24 +55,53 @@ export async function executeWithState<T>(
 }
 
 /**
- * Execute async function with retry logic
+ * Execute async function with retry logic and exponential backoff
+ * @param asyncFn - Function to execute
+ * @param maxRetries - Maximum number of retry attempts (default: 3)
+ * @param delayMs - Initial delay in milliseconds (default: 1000)
+ * @param signal - Optional AbortSignal to cancel retries
  */
 export async function executeWithRetry<T>(
   asyncFn: () => Promise<T>,
   maxRetries: number = 3,
-  delayMs: number = 1000
+  delayMs: number = 1000,
+  signal?: AbortSignal
 ): Promise<T> {
+  // Validate inputs
+  if (maxRetries < 1) {
+    throw new Error("maxRetries must be at least 1");
+  }
+  if (delayMs < 0) {
+    throw new Error("delayMs must be non-negative");
+  }
+
   let lastError: Error | null = null;
+  const MAX_DELAY_MS = 30000; // Cap at 30 seconds
 
   for (let attempt = 0; attempt < maxRetries; attempt++) {
+    // Check if aborted
+    if (signal?.aborted) {
+      throw new Error("Retry operation was aborted");
+    }
+
     try {
       return await asyncFn();
     } catch (error) {
       lastError = error as Error;
 
       if (attempt < maxRetries - 1) {
-        // Wait before retrying with exponential backoff
-        await new Promise((resolve) => setTimeout(resolve, delayMs * Math.pow(2, attempt)));
+        // Calculate exponential backoff delay using utility
+        const delay = calculateExponentialBackoff(delayMs, attempt);
+        const cappedDelay = clamp(delay, 0, MAX_DELAY_MS);
+
+        await new Promise<void>((resolve, reject) => {
+          const timeoutId = setTimeout(() => resolve(), cappedDelay);
+
+          signal?.addEventListener("abort", () => {
+            clearTimeout(timeoutId);
+            reject(new Error("Retry operation was aborted during delay"));
+          }, { once: true });
+        });
       }
     }
   }

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

@@ -0,0 +1,181 @@
+/**
+ * Calculation Utilities
+ * Common calculation and utility functions for numeric operations
+ */
+
+/**
+ * Generate a random unique identifier string
+ * @param length - Length of the random string (default: 9)
+ * @returns Random string in base-36
+ */
+export function generateRandomId(length: number = 9): string {
+  return Math.random().toString(36).substring(2, 2 + length);
+}
+
+/**
+ * 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)}`;
+}
+
+/**
+ * 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) {
+    return 0;
+  }
+  return Math.floor(maxTokens / tokensPerMessage);
+}
+
+/**
+ * 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) {
+    return 0;
+  }
+  return baseDelay * Math.pow(2, attempt);
+}
+
+/**
+ * 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 {
+  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
+ */
+export function calculatePercentage(
+  value: number,
+  total: number,
+  decimals: number = 2
+): number {
+  if (total === 0) {
+    return 0;
+  }
+  return Number(((value / total) * 100).toFixed(decimals));
+}
+
+/**
+ * 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 (currentSize > maxSize) {
+    return Math.floor(maxSize / 2);
+  }
+  return currentSize;
+}
+
+/**
+ * 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;
+  }
+  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;
+}
+
+/**
+ * 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 {
+  const exponentialDelay = calculateExponentialBackoff(baseDelay, attempt);
+  const jitter = exponentialDelay * jitterFactor * (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);
+}
+
+/**
+ * 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) {
+    return 0;
+  }
+  const seconds = milliseconds / 1000;
+  const kilobytes = bytes / 1024;
+  return Number((kilobytes / seconds).toFixed(2));
+}
+
+/**
+ * Calculate average from array of numbers
+ * @param values - Array of numbers
+ * @returns Average value or 0 if array is empty
+ */
+export function calculateAverage(values: number[]): number {
+  if (values.length === 0) {
+    return 0;
+  }
+  const sum = values.reduce((acc, val) => acc + val, 0);
+  return sum / values.length;
+}

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

@@ -84,3 +84,19 @@ export function formatMessagesForDisplay(messages: GroqMessage[]): string {
     })
     .join("\n\n---\n\n");
 }
+
+/**
+ * Clean JSON response by removing markdown code blocks
+ */
+export function cleanJsonResponse(content: string): string {
+  let cleaned = content.trim();
+  if (cleaned.startsWith("```json")) {
+    cleaned = cleaned.slice(7);
+  } else if (cleaned.startsWith("```")) {
+    cleaned = cleaned.slice(3);
+  }
+  if (cleaned.endsWith("```")) {
+    cleaned = cleaned.slice(0, -3);
+  }
+  return cleaned.trim();
+}

package/src/infrastructure/utils/index.ts

@@ -4,4 +4,5 @@
 
 export * from "./content-mapper.util";
 export * from "./error-mapper.util";
+export * from "./calculation.util";
 export * from "./async";

package/src/presentation/hooks/useGroq.ts

@@ -3,7 +3,7 @@
  * Main React hook for Groq text generation
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useMemo } from "react";
 import type { GroqGenerationConfig } from "../../domain/entities";
 import { textGeneration } from "../../infrastructure/services/TextGeneration";
 import { structuredText } from "../../infrastructure/services/StructuredText";
@@ -52,6 +52,7 @@ export interface UseGroqReturn {
 
 /**
  * Hook for Groq text generation
+ * Optimized to prevent unnecessary re-renders and memory leaks
  */
 export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
   const [isLoading, setIsLoading] = useState(false);
@@ -59,6 +60,17 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
   const [result, setResult] = useState<string | null>(null);
   const abortControllerRef = useRef<AbortController | null>(null);
 
+  // Memoize options to prevent unnecessary callback recreations
+  const stableOptions = useMemo(() => options, [
+    options.model,
+    options.generationConfig?.temperature,
+    options.generationConfig?.maxTokens,
+    options.generationConfig?.topP,
+    options.onStart,
+    options.onSuccess,
+    options.onError,
+  ]);
+
   const generate = useCallback(
     async (prompt: string, config?: GroqGenerationConfig): Promise<string> => {
       // Cancel any ongoing request
@@ -72,23 +84,23 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
       setResult(null);
 
       telemetry.log("groq_generate_start", { prompt: prompt.substring(0, 100) });
-      options.onStart?.();
+      stableOptions.onStart?.();
 
       try {
         const response = await textGeneration(prompt, {
-          model: options.model,
-          generationConfig: { ...options.generationConfig, ...config },
+          model: stableOptions.model,
+          generationConfig: { ...stableOptions.generationConfig, ...config },
         });
 
         setResult(response);
-        options.onSuccess?.(response);
+        stableOptions.onSuccess?.(response);
         telemetry.log("groq_generate_success", { responseLength: response.length });
 
         return response;
       } catch (err) {
         const errorMessage = getUserFriendlyError(err);
         setError(errorMessage);
-        options.onError?.(errorMessage);
+        stableOptions.onError?.(errorMessage);
         telemetry.log("groq_generate_error", { error: errorMessage });
         throw err;
       } finally {
@@ -96,7 +108,7 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
         abortControllerRef.current = null;
       }
     },
-    [options]
+    [stableOptions]
   );
 
   const generateJSON = useCallback(
@@ -115,24 +127,24 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
       setResult(null);
 
       telemetry.log("groq_generate_json_start", { prompt: prompt.substring(0, 100) });
-      options.onStart?.();
+      stableOptions.onStart?.();
 
       try {
         const response = await structuredText<T>(prompt, {
-          model: options.model,
-          generationConfig: { ...options.generationConfig, ...config },
+          model: stableOptions.model,
+          generationConfig: { ...stableOptions.generationConfig, ...config },
           schema: config?.schema,
         });
 
         setResult(JSON.stringify(response, null, 2));
-        options.onSuccess?.(JSON.stringify(response, null, 2));
+        stableOptions.onSuccess?.(JSON.stringify(response, null, 2));
         telemetry.log("groq_generate_json_success");
 
         return response;
       } catch (err) {
         const errorMessage = getUserFriendlyError(err);
         setError(errorMessage);
-        options.onError?.(errorMessage);
+        stableOptions.onError?.(errorMessage);
         telemetry.log("groq_generate_json_error", { error: errorMessage });
         throw err;
       } finally {
@@ -140,7 +152,7 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
         abortControllerRef.current = null;
       }
     },
-    [options]
+    [stableOptions]
   );
 
   const stream = useCallback(
@@ -162,12 +174,12 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
       let fullContent = "";
 
       telemetry.log("groq_stream_start", { prompt: prompt.substring(0, 100) });
-      options.onStart?.();
+      stableOptions.onStart?.();
 
       try {
         for await (const streamingResult of streaming(prompt, {
-          model: options.model,
-          generationConfig: { ...options.generationConfig, ...config },
+          model: stableOptions.model,
+          generationConfig: { ...stableOptions.generationConfig, ...config },
           callbacks: {
             onChunk: (c) => {
               fullContent += c;
@@ -180,12 +192,12 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
         }
 
         setResult(fullContent);
-        options.onSuccess?.(fullContent);
+        stableOptions.onSuccess?.(fullContent);
         telemetry.log("groq_stream_success", { contentLength: fullContent.length });
       } catch (err) {
         const errorMessage = getUserFriendlyError(err);
         setError(errorMessage);
-        options.onError?.(errorMessage);
+        stableOptions.onError?.(errorMessage);
         telemetry.log("groq_stream_error", { error: errorMessage });
         throw err;
       } finally {
@@ -193,7 +205,7 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
         abortControllerRef.current = null;
       }
     },
-    [options]
+    [stableOptions]
   );
 
   const reset = useCallback(() => {

package/src/presentation/hooks/useOperationManager.ts

@@ -3,7 +3,7 @@
  * Manages async operations with loading, error, and success states
  */
 
-import { useState, useCallback, useRef } from "react";
+import { useState, useCallback, useRef, useMemo } from "react";
 import { getUserFriendlyError } from "../../infrastructure/utils/error-mapper.util";
 import { telemetry } from "../../infrastructure/telemetry";
 
@@ -26,14 +26,23 @@ export interface UseOperationManagerOptions<T> {
 
 /**
  * Hook for managing async operations
+ * Optimized to prevent unnecessary re-renders
  */
 export function useOperationManager<T = unknown>(
   options: UseOperationManagerOptions<T> = {}
 ) {
+  // Memoize options to prevent unnecessary callback recreations
+  const stableOptions = useMemo(() => options, [
+    options.initialData,
+    options.onStart,
+    options.onSuccess,
+    options.onError,
+  ]);
+
   const [state, setState] = useState<OperationState<T>>({
     isLoading: false,
     error: null,
-    data: options.initialData ?? null,
+    data: stableOptions.initialData ?? null,
   });
 
   const abortControllerRef = useRef<AbortController | null>(null);
@@ -56,27 +65,27 @@ export function useOperationManager<T = unknown>(
       setState((prev) => ({ ...prev, isLoading: true, error: null }));
 
       telemetry.log(`${operationName}_start`);
-      options.onStart?.();
+      stableOptions.onStart?.();
 
       try {
         const result = await asyncFn(abortControllerRef.current.signal);
 
         setState((prev) => ({ ...prev, isLoading: false, data: result as unknown as T }));
-        options.onSuccess?.(result as unknown as T);
+        stableOptions.onSuccess?.(result as unknown as T);
         telemetry.log(`${operationName}_success`);
 
         return result;
       } catch (error) {
         const errorMessage = getUserFriendlyError(error);
         setState((prev) => ({ ...prev, isLoading: false, error: errorMessage }));
-        options.onError?.(errorMessage);
+        stableOptions.onError?.(errorMessage);
         telemetry.log(`${operationName}_error`, { error: errorMessage });
         throw error;
       } finally {
         abortControllerRef.current = null;
       }
     },
-    [options]
+    [stableOptions]
   );
 
   const reset = useCallback(() => {
@@ -88,9 +97,9 @@ export function useOperationManager<T = unknown>(
       ...prev,
       isLoading: false,
       error: null,
-      data: options.initialData ?? null,
+      data: stableOptions.initialData ?? null,
     }));
-  }, [options.initialData]);
+  }, [stableOptions.initialData]);
 
   const clearError = useCallback(() => {
     setState((prev) => ({ ...prev, error: null }));